module Data.FpML.V53.Mktenv
( module Data.FpML.V53.Mktenv
, module Data.FpML.V53.Doc
, module Data.FpML.V53.Asset
, module Data.FpML.V53.Riskdef
, module Data.FpML.V53.CD
) 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.Doc
import Data.FpML.V53.Asset
import Data.FpML.V53.Riskdef
import Data.FpML.V53.CD
data CompoundingFrequency = CompoundingFrequency Scheme CompoundingFrequencyAttributes deriving (Eq,Show)
data CompoundingFrequencyAttributes = CompoundingFrequencyAttributes
{ compoFrequAttrib_compoundingFrequencyScheme :: Maybe Xsd.AnyURI
}
deriving (Eq,Show)
instance SchemaType CompoundingFrequency where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ do
a0 <- optional $ getAttribute "compoundingFrequencyScheme" e pos
reparse [CElem e pos]
v <- parseSchemaType s
return $ CompoundingFrequency v (CompoundingFrequencyAttributes a0)
schemaTypeToXML s (CompoundingFrequency bt at) =
addXMLAttributes [ maybe [] (toXMLAttribute "compoundingFrequencyScheme") $ compoFrequAttrib_compoundingFrequencyScheme at
]
$ schemaTypeToXML s bt
instance Extension CompoundingFrequency Scheme where
supertype (CompoundingFrequency s _) = s
data CreditCurve = CreditCurve
{ creditCurve_ID :: Maybe Xsd.ID
, creditCurve_name :: Maybe Xsd.NormalizedString
, creditCurve_currency :: Maybe Currency
, creditCurve_choice2 :: (Maybe (OneOf2 LegalEntity LegalEntityReference))
, creditCurve_creditEvents :: Maybe CreditEvents
, creditCurve_seniority :: Maybe CreditSeniority
, creditCurve_secured :: Maybe Xsd.Boolean
, creditCurve_obligationCurrency :: Maybe Currency
, creditCurve_obligations :: Maybe Obligations
, creditCurve_deliverableObligations :: Maybe DeliverableObligations
}
deriving (Eq,Show)
instance SchemaType CreditCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (CreditCurve a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "currency")
`apply` optional (oneOf' [ ("LegalEntity", fmap OneOf2 (parseSchemaType "referenceEntity"))
, ("LegalEntityReference", fmap TwoOf2 (parseSchemaType "creditEntityReference"))
])
`apply` optional (parseSchemaType "creditEvents")
`apply` optional (parseSchemaType "seniority")
`apply` optional (parseSchemaType "secured")
`apply` optional (parseSchemaType "obligationCurrency")
`apply` optional (parseSchemaType "obligations")
`apply` optional (parseSchemaType "deliverableObligations")
schemaTypeToXML s x@CreditCurve{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ creditCurve_ID x
]
[ maybe [] (schemaTypeToXML "name") $ creditCurve_name x
, maybe [] (schemaTypeToXML "currency") $ creditCurve_currency x
, maybe [] (foldOneOf2 (schemaTypeToXML "referenceEntity")
(schemaTypeToXML "creditEntityReference")
) $ creditCurve_choice2 x
, maybe [] (schemaTypeToXML "creditEvents") $ creditCurve_creditEvents x
, maybe [] (schemaTypeToXML "seniority") $ creditCurve_seniority x
, maybe [] (schemaTypeToXML "secured") $ creditCurve_secured x
, maybe [] (schemaTypeToXML "obligationCurrency") $ creditCurve_obligationCurrency x
, maybe [] (schemaTypeToXML "obligations") $ creditCurve_obligations x
, maybe [] (schemaTypeToXML "deliverableObligations") $ creditCurve_deliverableObligations x
]
instance Extension CreditCurve PricingStructure where
supertype v = PricingStructure_CreditCurve v
data CreditCurveValuation = CreditCurveValuation
{ creditCurveVal_ID :: Maybe Xsd.ID
, creditCurveVal_definitionRef :: Maybe Xsd.IDREF
, creditCurveVal_objectReference :: Maybe AnyAssetReference
, creditCurveVal_valuationScenarioReference :: Maybe ValuationScenarioReference
, creditCurveVal_baseDate :: Maybe IdentifiedDate
, creditCurveVal_spotDate :: Maybe IdentifiedDate
, creditCurveVal_inputDataDate :: Maybe IdentifiedDate
, creditCurveVal_endDate :: Maybe IdentifiedDate
, creditCurveVal_buildDateTime :: Maybe Xsd.DateTime
, creditCurveVal_inputs :: Maybe QuotedAssetSet
, creditCurveVal_defaultProbabilityCurve :: Maybe DefaultProbabilityCurve
, creditCurveVal_choice9 :: (Maybe (OneOf2 Xsd.Decimal TermCurve))
}
deriving (Eq,Show)
instance SchemaType CreditCurveValuation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (CreditCurveValuation a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseDate")
`apply` optional (parseSchemaType "spotDate")
`apply` optional (parseSchemaType "inputDataDate")
`apply` optional (parseSchemaType "endDate")
`apply` optional (parseSchemaType "buildDateTime")
`apply` optional (parseSchemaType "inputs")
`apply` optional (parseSchemaType "defaultProbabilityCurve")
`apply` optional (oneOf' [ ("Xsd.Decimal", fmap OneOf2 (parseSchemaType "recoveryRate"))
, ("TermCurve", fmap TwoOf2 (parseSchemaType "recoveryRateCurve"))
])
schemaTypeToXML s x@CreditCurveValuation{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ creditCurveVal_ID x
, maybe [] (toXMLAttribute "definitionRef") $ creditCurveVal_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ creditCurveVal_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ creditCurveVal_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseDate") $ creditCurveVal_baseDate x
, maybe [] (schemaTypeToXML "spotDate") $ creditCurveVal_spotDate x
, maybe [] (schemaTypeToXML "inputDataDate") $ creditCurveVal_inputDataDate x
, maybe [] (schemaTypeToXML "endDate") $ creditCurveVal_endDate x
, maybe [] (schemaTypeToXML "buildDateTime") $ creditCurveVal_buildDateTime x
, maybe [] (schemaTypeToXML "inputs") $ creditCurveVal_inputs x
, maybe [] (schemaTypeToXML "defaultProbabilityCurve") $ creditCurveVal_defaultProbabilityCurve x
, maybe [] (foldOneOf2 (schemaTypeToXML "recoveryRate")
(schemaTypeToXML "recoveryRateCurve")
) $ creditCurveVal_choice9 x
]
instance Extension CreditCurveValuation PricingStructureValuation where
supertype (CreditCurveValuation a0 a1 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9) =
PricingStructureValuation a0 a1 e0 e1 e2 e3 e4 e5 e6
instance Extension CreditCurveValuation Valuation where
supertype = (supertype :: PricingStructureValuation -> Valuation)
. (supertype :: CreditCurveValuation -> PricingStructureValuation)
data DefaultProbabilityCurve = DefaultProbabilityCurve
{ defaultProbabCurve_ID :: Maybe Xsd.ID
, defaultProbabCurve_definitionRef :: Maybe Xsd.IDREF
, defaultProbabCurve_objectReference :: Maybe AnyAssetReference
, defaultProbabCurve_valuationScenarioReference :: Maybe ValuationScenarioReference
, defaultProbabCurve_baseDate :: Maybe IdentifiedDate
, defaultProbabCurve_spotDate :: Maybe IdentifiedDate
, defaultProbabCurve_inputDataDate :: Maybe IdentifiedDate
, defaultProbabCurve_endDate :: Maybe IdentifiedDate
, defaultProbabCurve_buildDateTime :: Maybe Xsd.DateTime
, defaultProbabCurve_baseYieldCurve :: Maybe PricingStructureReference
, defaultProbabCurve_defaultProbabilities :: Maybe TermCurve
}
deriving (Eq,Show)
instance SchemaType DefaultProbabilityCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (DefaultProbabilityCurve a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseDate")
`apply` optional (parseSchemaType "spotDate")
`apply` optional (parseSchemaType "inputDataDate")
`apply` optional (parseSchemaType "endDate")
`apply` optional (parseSchemaType "buildDateTime")
`apply` optional (parseSchemaType "baseYieldCurve")
`apply` optional (parseSchemaType "defaultProbabilities")
schemaTypeToXML s x@DefaultProbabilityCurve{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ defaultProbabCurve_ID x
, maybe [] (toXMLAttribute "definitionRef") $ defaultProbabCurve_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ defaultProbabCurve_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ defaultProbabCurve_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseDate") $ defaultProbabCurve_baseDate x
, maybe [] (schemaTypeToXML "spotDate") $ defaultProbabCurve_spotDate x
, maybe [] (schemaTypeToXML "inputDataDate") $ defaultProbabCurve_inputDataDate x
, maybe [] (schemaTypeToXML "endDate") $ defaultProbabCurve_endDate x
, maybe [] (schemaTypeToXML "buildDateTime") $ defaultProbabCurve_buildDateTime x
, maybe [] (schemaTypeToXML "baseYieldCurve") $ defaultProbabCurve_baseYieldCurve x
, maybe [] (schemaTypeToXML "defaultProbabilities") $ defaultProbabCurve_defaultProbabilities x
]
instance Extension DefaultProbabilityCurve PricingStructureValuation where
supertype (DefaultProbabilityCurve a0 a1 e0 e1 e2 e3 e4 e5 e6 e7 e8) =
PricingStructureValuation a0 a1 e0 e1 e2 e3 e4 e5 e6
instance Extension DefaultProbabilityCurve Valuation where
supertype = (supertype :: PricingStructureValuation -> Valuation)
. (supertype :: DefaultProbabilityCurve -> PricingStructureValuation)
data ForwardRateCurve = ForwardRateCurve
{ forwardRateCurve_assetReference :: Maybe AssetReference
, forwardRateCurve_rateCurve :: Maybe TermCurve
}
deriving (Eq,Show)
instance SchemaType ForwardRateCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ForwardRateCurve
`apply` optional (parseSchemaType "assetReference")
`apply` optional (parseSchemaType "rateCurve")
schemaTypeToXML s x@ForwardRateCurve{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "assetReference") $ forwardRateCurve_assetReference x
, maybe [] (schemaTypeToXML "rateCurve") $ forwardRateCurve_rateCurve x
]
data FxCurve = FxCurve
{ fxCurve_ID :: Maybe Xsd.ID
, fxCurve_name :: Maybe Xsd.NormalizedString
, fxCurve_currency :: Maybe Currency
, fxCurve_quotedCurrencyPair :: Maybe QuotedCurrencyPair
}
deriving (Eq,Show)
instance SchemaType FxCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (FxCurve a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "currency")
`apply` optional (parseSchemaType "quotedCurrencyPair")
schemaTypeToXML s x@FxCurve{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ fxCurve_ID x
]
[ maybe [] (schemaTypeToXML "name") $ fxCurve_name x
, maybe [] (schemaTypeToXML "currency") $ fxCurve_currency x
, maybe [] (schemaTypeToXML "quotedCurrencyPair") $ fxCurve_quotedCurrencyPair x
]
instance Extension FxCurve PricingStructure where
supertype v = PricingStructure_FxCurve v
data FxCurveValuation = FxCurveValuation
{ fxCurveVal_ID :: Maybe Xsd.ID
, fxCurveVal_definitionRef :: Maybe Xsd.IDREF
, fxCurveVal_objectReference :: Maybe AnyAssetReference
, fxCurveVal_valuationScenarioReference :: Maybe ValuationScenarioReference
, fxCurveVal_baseDate :: Maybe IdentifiedDate
, fxCurveVal_spotDate :: Maybe IdentifiedDate
, fxCurveVal_inputDataDate :: Maybe IdentifiedDate
, fxCurveVal_endDate :: Maybe IdentifiedDate
, fxCurveVal_buildDateTime :: Maybe Xsd.DateTime
, fxCurveVal_settlementCurrencyYieldCurve :: Maybe PricingStructureReference
, fxCurveVal_forecastCurrencyYieldCurve :: Maybe PricingStructureReference
, fxCurveVal_spotRate :: Maybe FxRateSet
, fxCurveVal_fxForwardCurve :: Maybe TermCurve
, fxCurveVal_fxForwardPointsCurve :: Maybe TermCurve
}
deriving (Eq,Show)
instance SchemaType FxCurveValuation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (FxCurveValuation a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseDate")
`apply` optional (parseSchemaType "spotDate")
`apply` optional (parseSchemaType "inputDataDate")
`apply` optional (parseSchemaType "endDate")
`apply` optional (parseSchemaType "buildDateTime")
`apply` optional (parseSchemaType "settlementCurrencyYieldCurve")
`apply` optional (parseSchemaType "forecastCurrencyYieldCurve")
`apply` optional (parseSchemaType "spotRate")
`apply` optional (parseSchemaType "fxForwardCurve")
`apply` optional (parseSchemaType "fxForwardPointsCurve")
schemaTypeToXML s x@FxCurveValuation{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ fxCurveVal_ID x
, maybe [] (toXMLAttribute "definitionRef") $ fxCurveVal_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ fxCurveVal_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ fxCurveVal_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseDate") $ fxCurveVal_baseDate x
, maybe [] (schemaTypeToXML "spotDate") $ fxCurveVal_spotDate x
, maybe [] (schemaTypeToXML "inputDataDate") $ fxCurveVal_inputDataDate x
, maybe [] (schemaTypeToXML "endDate") $ fxCurveVal_endDate x
, maybe [] (schemaTypeToXML "buildDateTime") $ fxCurveVal_buildDateTime x
, maybe [] (schemaTypeToXML "settlementCurrencyYieldCurve") $ fxCurveVal_settlementCurrencyYieldCurve x
, maybe [] (schemaTypeToXML "forecastCurrencyYieldCurve") $ fxCurveVal_forecastCurrencyYieldCurve x
, maybe [] (schemaTypeToXML "spotRate") $ fxCurveVal_spotRate x
, maybe [] (schemaTypeToXML "fxForwardCurve") $ fxCurveVal_fxForwardCurve x
, maybe [] (schemaTypeToXML "fxForwardPointsCurve") $ fxCurveVal_fxForwardPointsCurve x
]
instance Extension FxCurveValuation PricingStructureValuation where
supertype (FxCurveValuation a0 a1 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11) =
PricingStructureValuation a0 a1 e0 e1 e2 e3 e4 e5 e6
instance Extension FxCurveValuation Valuation where
supertype = (supertype :: PricingStructureValuation -> Valuation)
. (supertype :: FxCurveValuation -> PricingStructureValuation)
data FxRateSet = FxRateSet
{ fxRateSet_instrumentSet :: Maybe InstrumentSet
, fxRateSet_assetQuote :: [BasicAssetValuation]
}
deriving (Eq,Show)
instance SchemaType FxRateSet where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return FxRateSet
`apply` optional (parseSchemaType "instrumentSet")
`apply` many (parseSchemaType "assetQuote")
schemaTypeToXML s x@FxRateSet{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "instrumentSet") $ fxRateSet_instrumentSet x
, concatMap (schemaTypeToXML "assetQuote") $ fxRateSet_assetQuote x
]
instance Extension FxRateSet QuotedAssetSet where
supertype (FxRateSet e0 e1) =
QuotedAssetSet e0 e1
data MultiDimensionalPricingData = MultiDimensionalPricingData
{ multiDimensPricingData_measureType :: Maybe AssetMeasureType
, multiDimensPricingData_quoteUnits :: Maybe PriceQuoteUnits
, multiDimensPricingData_side :: Maybe QuotationSideEnum
, multiDimensPricingData_currency :: Maybe Currency
, multiDimensPricingData_currencyType :: Maybe ReportingCurrencyType
, multiDimensPricingData_timing :: Maybe QuoteTiming
, multiDimensPricingData_choice6 :: (Maybe (OneOf2 BusinessCenter ExchangeId))
, multiDimensPricingData_informationSource :: [InformationSource]
, multiDimensPricingData_pricingModel :: Maybe PricingModel
, multiDimensPricingData_time :: Maybe Xsd.DateTime
, multiDimensPricingData_valuationDate :: Maybe Xsd.Date
, multiDimensPricingData_expiryTime :: Maybe Xsd.DateTime
, multiDimensPricingData_cashflowType :: Maybe CashflowType
, multiDimensPricingData_point :: [PricingStructurePoint]
}
deriving (Eq,Show)
instance SchemaType MultiDimensionalPricingData where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return MultiDimensionalPricingData
`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 "point")
schemaTypeToXML s x@MultiDimensionalPricingData{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "measureType") $ multiDimensPricingData_measureType x
, maybe [] (schemaTypeToXML "quoteUnits") $ multiDimensPricingData_quoteUnits x
, maybe [] (schemaTypeToXML "side") $ multiDimensPricingData_side x
, maybe [] (schemaTypeToXML "currency") $ multiDimensPricingData_currency x
, maybe [] (schemaTypeToXML "currencyType") $ multiDimensPricingData_currencyType x
, maybe [] (schemaTypeToXML "timing") $ multiDimensPricingData_timing x
, maybe [] (foldOneOf2 (schemaTypeToXML "businessCenter")
(schemaTypeToXML "exchangeId")
) $ multiDimensPricingData_choice6 x
, concatMap (schemaTypeToXML "informationSource") $ multiDimensPricingData_informationSource x
, maybe [] (schemaTypeToXML "pricingModel") $ multiDimensPricingData_pricingModel x
, maybe [] (schemaTypeToXML "time") $ multiDimensPricingData_time x
, maybe [] (schemaTypeToXML "valuationDate") $ multiDimensPricingData_valuationDate x
, maybe [] (schemaTypeToXML "expiryTime") $ multiDimensPricingData_expiryTime x
, maybe [] (schemaTypeToXML "cashflowType") $ multiDimensPricingData_cashflowType x
, concatMap (schemaTypeToXML "point") $ multiDimensPricingData_point x
]
data ParametricAdjustment = ParametricAdjustment
{ paramAdjust_name :: Maybe Xsd.NormalizedString
, paramAdjust_inputUnits :: Maybe PriceQuoteUnits
, paramAdjust_datapoint :: [ParametricAdjustmentPoint]
}
deriving (Eq,Show)
instance SchemaType ParametricAdjustment where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ParametricAdjustment
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "inputUnits")
`apply` many (parseSchemaType "datapoint")
schemaTypeToXML s x@ParametricAdjustment{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "name") $ paramAdjust_name x
, maybe [] (schemaTypeToXML "inputUnits") $ paramAdjust_inputUnits x
, concatMap (schemaTypeToXML "datapoint") $ paramAdjust_datapoint x
]
data ParametricAdjustmentPoint = ParametricAdjustmentPoint
{ paramAdjustPoint_parameterValue :: Maybe Xsd.Decimal
, paramAdjustPoint_adjustmentValue :: Maybe Xsd.Decimal
}
deriving (Eq,Show)
instance SchemaType ParametricAdjustmentPoint where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ParametricAdjustmentPoint
`apply` optional (parseSchemaType "parameterValue")
`apply` optional (parseSchemaType "adjustmentValue")
schemaTypeToXML s x@ParametricAdjustmentPoint{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "parameterValue") $ paramAdjustPoint_parameterValue x
, maybe [] (schemaTypeToXML "adjustmentValue") $ paramAdjustPoint_adjustmentValue x
]
data PricingStructurePoint = PricingStructurePoint
{ pricingStructPoint_ID :: Maybe Xsd.ID
, pricingStructPoint_choice0 :: (Maybe (OneOf2 PricingDataPointCoordinate PricingDataPointCoordinateReference))
, pricingStructPoint_choice1 :: (Maybe (OneOf2 Asset AssetReference))
, pricingStructPoint_value :: Maybe Xsd.Decimal
, pricingStructPoint_measureType :: Maybe AssetMeasureType
, pricingStructPoint_quoteUnits :: Maybe PriceQuoteUnits
, pricingStructPoint_side :: Maybe QuotationSideEnum
, pricingStructPoint_currency :: Maybe Currency
, pricingStructPoint_currencyType :: Maybe ReportingCurrencyType
, pricingStructPoint_timing :: Maybe QuoteTiming
, pricingStructPoint_choice9 :: (Maybe (OneOf2 BusinessCenter ExchangeId))
, pricingStructPoint_informationSource :: [InformationSource]
, pricingStructPoint_pricingModel :: Maybe PricingModel
, pricingStructPoint_time :: Maybe Xsd.DateTime
, pricingStructPoint_valuationDate :: Maybe Xsd.Date
, pricingStructPoint_expiryTime :: Maybe Xsd.DateTime
, pricingStructPoint_cashflowType :: Maybe CashflowType
}
deriving (Eq,Show)
instance SchemaType PricingStructurePoint where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (PricingStructurePoint a0)
`apply` optional (oneOf' [ ("PricingDataPointCoordinate", fmap OneOf2 (parseSchemaType "coordinate"))
, ("PricingDataPointCoordinateReference", fmap TwoOf2 (parseSchemaType "coordinateReference"))
])
`apply` optional (oneOf' [ ("Asset", fmap OneOf2 (elementUnderlyingAsset))
, ("AssetReference", fmap TwoOf2 (parseSchemaType "underlyingAssetReference"))
])
`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")
schemaTypeToXML s x@PricingStructurePoint{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ pricingStructPoint_ID x
]
[ maybe [] (foldOneOf2 (schemaTypeToXML "coordinate")
(schemaTypeToXML "coordinateReference")
) $ pricingStructPoint_choice0 x
, maybe [] (foldOneOf2 (elementToXMLUnderlyingAsset)
(schemaTypeToXML "underlyingAssetReference")
) $ pricingStructPoint_choice1 x
, maybe [] (schemaTypeToXML "value") $ pricingStructPoint_value x
, maybe [] (schemaTypeToXML "measureType") $ pricingStructPoint_measureType x
, maybe [] (schemaTypeToXML "quoteUnits") $ pricingStructPoint_quoteUnits x
, maybe [] (schemaTypeToXML "side") $ pricingStructPoint_side x
, maybe [] (schemaTypeToXML "currency") $ pricingStructPoint_currency x
, maybe [] (schemaTypeToXML "currencyType") $ pricingStructPoint_currencyType x
, maybe [] (schemaTypeToXML "timing") $ pricingStructPoint_timing x
, maybe [] (foldOneOf2 (schemaTypeToXML "businessCenter")
(schemaTypeToXML "exchangeId")
) $ pricingStructPoint_choice9 x
, concatMap (schemaTypeToXML "informationSource") $ pricingStructPoint_informationSource x
, maybe [] (schemaTypeToXML "pricingModel") $ pricingStructPoint_pricingModel x
, maybe [] (schemaTypeToXML "time") $ pricingStructPoint_time x
, maybe [] (schemaTypeToXML "valuationDate") $ pricingStructPoint_valuationDate x
, maybe [] (schemaTypeToXML "expiryTime") $ pricingStructPoint_expiryTime x
, maybe [] (schemaTypeToXML "cashflowType") $ pricingStructPoint_cashflowType x
]
data TermCurve = TermCurve
{ termCurve_interpolationMethod :: Maybe InterpolationMethod
, termCurve_extrapolationPermitted :: Maybe Xsd.Boolean
, termCurve_point :: [TermPoint]
}
deriving (Eq,Show)
instance SchemaType TermCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return TermCurve
`apply` optional (parseSchemaType "interpolationMethod")
`apply` optional (parseSchemaType "extrapolationPermitted")
`apply` many (parseSchemaType "point")
schemaTypeToXML s x@TermCurve{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "interpolationMethod") $ termCurve_interpolationMethod x
, maybe [] (schemaTypeToXML "extrapolationPermitted") $ termCurve_extrapolationPermitted x
, concatMap (schemaTypeToXML "point") $ termCurve_point x
]
data TermPoint = TermPoint
{ termPoint_ID :: Maybe Xsd.ID
, termPoint_term :: Maybe TimeDimension
, termPoint_bid :: Maybe Xsd.Decimal
, termPoint_mid :: Maybe Xsd.Decimal
, termPoint_ask :: Maybe Xsd.Decimal
, termPoint_spreadValue :: Maybe Xsd.Decimal
, termPoint_definition :: Maybe AssetReference
}
deriving (Eq,Show)
instance SchemaType TermPoint where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (TermPoint a0)
`apply` optional (parseSchemaType "term")
`apply` optional (parseSchemaType "bid")
`apply` optional (parseSchemaType "mid")
`apply` optional (parseSchemaType "ask")
`apply` optional (parseSchemaType "spreadValue")
`apply` optional (parseSchemaType "definition")
schemaTypeToXML s x@TermPoint{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ termPoint_ID x
]
[ maybe [] (schemaTypeToXML "term") $ termPoint_term x
, maybe [] (schemaTypeToXML "bid") $ termPoint_bid x
, maybe [] (schemaTypeToXML "mid") $ termPoint_mid x
, maybe [] (schemaTypeToXML "ask") $ termPoint_ask x
, maybe [] (schemaTypeToXML "spreadValue") $ termPoint_spreadValue x
, maybe [] (schemaTypeToXML "definition") $ termPoint_definition x
]
data VolatilityMatrix = VolatilityMatrix
{ volatMatrix_ID :: Maybe Xsd.ID
, volatMatrix_definitionRef :: Maybe Xsd.IDREF
, volatMatrix_objectReference :: Maybe AnyAssetReference
, volatMatrix_valuationScenarioReference :: Maybe ValuationScenarioReference
, volatMatrix_baseDate :: Maybe IdentifiedDate
, volatMatrix_spotDate :: Maybe IdentifiedDate
, volatMatrix_inputDataDate :: Maybe IdentifiedDate
, volatMatrix_endDate :: Maybe IdentifiedDate
, volatMatrix_buildDateTime :: Maybe Xsd.DateTime
, volatMatrix_dataPoints :: Maybe MultiDimensionalPricingData
, volatMatrix_adjustment :: [ParametricAdjustment]
}
deriving (Eq,Show)
instance SchemaType VolatilityMatrix where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (VolatilityMatrix a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseDate")
`apply` optional (parseSchemaType "spotDate")
`apply` optional (parseSchemaType "inputDataDate")
`apply` optional (parseSchemaType "endDate")
`apply` optional (parseSchemaType "buildDateTime")
`apply` optional (parseSchemaType "dataPoints")
`apply` many (parseSchemaType "adjustment")
schemaTypeToXML s x@VolatilityMatrix{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ volatMatrix_ID x
, maybe [] (toXMLAttribute "definitionRef") $ volatMatrix_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ volatMatrix_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ volatMatrix_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseDate") $ volatMatrix_baseDate x
, maybe [] (schemaTypeToXML "spotDate") $ volatMatrix_spotDate x
, maybe [] (schemaTypeToXML "inputDataDate") $ volatMatrix_inputDataDate x
, maybe [] (schemaTypeToXML "endDate") $ volatMatrix_endDate x
, maybe [] (schemaTypeToXML "buildDateTime") $ volatMatrix_buildDateTime x
, maybe [] (schemaTypeToXML "dataPoints") $ volatMatrix_dataPoints x
, concatMap (schemaTypeToXML "adjustment") $ volatMatrix_adjustment x
]
instance Extension VolatilityMatrix PricingStructureValuation where
supertype (VolatilityMatrix a0 a1 e0 e1 e2 e3 e4 e5 e6 e7 e8) =
PricingStructureValuation a0 a1 e0 e1 e2 e3 e4 e5 e6
instance Extension VolatilityMatrix Valuation where
supertype = (supertype :: PricingStructureValuation -> Valuation)
. (supertype :: VolatilityMatrix -> PricingStructureValuation)
data VolatilityRepresentation = VolatilityRepresentation
{ volatRepres_ID :: Maybe Xsd.ID
, volatRepres_name :: Maybe Xsd.NormalizedString
, volatRepres_currency :: Maybe Currency
, volatRepres_asset :: Maybe AnyAssetReference
}
deriving (Eq,Show)
instance SchemaType VolatilityRepresentation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (VolatilityRepresentation a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "currency")
`apply` optional (parseSchemaType "asset")
schemaTypeToXML s x@VolatilityRepresentation{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ volatRepres_ID x
]
[ maybe [] (schemaTypeToXML "name") $ volatRepres_name x
, maybe [] (schemaTypeToXML "currency") $ volatRepres_currency x
, maybe [] (schemaTypeToXML "asset") $ volatRepres_asset x
]
instance Extension VolatilityRepresentation PricingStructure where
supertype v = PricingStructure_VolatilityRepresentation v
data YieldCurve = YieldCurve
{ yieldCurve_ID :: Maybe Xsd.ID
, yieldCurve_name :: Maybe Xsd.NormalizedString
, yieldCurve_currency :: Maybe Currency
, yieldCurve_algorithm :: Maybe Xsd.XsdString
, yieldCurve_forecastRateIndex :: Maybe ForecastRateIndex
}
deriving (Eq,Show)
instance SchemaType YieldCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
commit $ interior e $ return (YieldCurve a0)
`apply` optional (parseSchemaType "name")
`apply` optional (parseSchemaType "currency")
`apply` optional (parseSchemaType "algorithm")
`apply` optional (parseSchemaType "forecastRateIndex")
schemaTypeToXML s x@YieldCurve{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ yieldCurve_ID x
]
[ maybe [] (schemaTypeToXML "name") $ yieldCurve_name x
, maybe [] (schemaTypeToXML "currency") $ yieldCurve_currency x
, maybe [] (schemaTypeToXML "algorithm") $ yieldCurve_algorithm x
, maybe [] (schemaTypeToXML "forecastRateIndex") $ yieldCurve_forecastRateIndex x
]
instance Extension YieldCurve PricingStructure where
supertype v = PricingStructure_YieldCurve v
data YieldCurveValuation = YieldCurveValuation
{ yieldCurveVal_ID :: Maybe Xsd.ID
, yieldCurveVal_definitionRef :: Maybe Xsd.IDREF
, yieldCurveVal_objectReference :: Maybe AnyAssetReference
, yieldCurveVal_valuationScenarioReference :: Maybe ValuationScenarioReference
, yieldCurveVal_baseDate :: Maybe IdentifiedDate
, yieldCurveVal_spotDate :: Maybe IdentifiedDate
, yieldCurveVal_inputDataDate :: Maybe IdentifiedDate
, yieldCurveVal_endDate :: Maybe IdentifiedDate
, yieldCurveVal_buildDateTime :: Maybe Xsd.DateTime
, yieldCurveVal_inputs :: Maybe QuotedAssetSet
, yieldCurveVal_zeroCurve :: Maybe ZeroRateCurve
, yieldCurveVal_forwardCurve :: [ForwardRateCurve]
, yieldCurveVal_discountFactorCurve :: Maybe TermCurve
}
deriving (Eq,Show)
instance SchemaType YieldCurveValuation where
parseSchemaType s = do
(pos,e) <- posnElement [s]
a0 <- optional $ getAttribute "id" e pos
a1 <- optional $ getAttribute "definitionRef" e pos
commit $ interior e $ return (YieldCurveValuation a0 a1)
`apply` optional (parseSchemaType "objectReference")
`apply` optional (parseSchemaType "valuationScenarioReference")
`apply` optional (parseSchemaType "baseDate")
`apply` optional (parseSchemaType "spotDate")
`apply` optional (parseSchemaType "inputDataDate")
`apply` optional (parseSchemaType "endDate")
`apply` optional (parseSchemaType "buildDateTime")
`apply` optional (parseSchemaType "inputs")
`apply` optional (parseSchemaType "zeroCurve")
`apply` many (parseSchemaType "forwardCurve")
`apply` optional (parseSchemaType "discountFactorCurve")
schemaTypeToXML s x@YieldCurveValuation{} =
toXMLElement s [ maybe [] (toXMLAttribute "id") $ yieldCurveVal_ID x
, maybe [] (toXMLAttribute "definitionRef") $ yieldCurveVal_definitionRef x
]
[ maybe [] (schemaTypeToXML "objectReference") $ yieldCurveVal_objectReference x
, maybe [] (schemaTypeToXML "valuationScenarioReference") $ yieldCurveVal_valuationScenarioReference x
, maybe [] (schemaTypeToXML "baseDate") $ yieldCurveVal_baseDate x
, maybe [] (schemaTypeToXML "spotDate") $ yieldCurveVal_spotDate x
, maybe [] (schemaTypeToXML "inputDataDate") $ yieldCurveVal_inputDataDate x
, maybe [] (schemaTypeToXML "endDate") $ yieldCurveVal_endDate x
, maybe [] (schemaTypeToXML "buildDateTime") $ yieldCurveVal_buildDateTime x
, maybe [] (schemaTypeToXML "inputs") $ yieldCurveVal_inputs x
, maybe [] (schemaTypeToXML "zeroCurve") $ yieldCurveVal_zeroCurve x
, concatMap (schemaTypeToXML "forwardCurve") $ yieldCurveVal_forwardCurve x
, maybe [] (schemaTypeToXML "discountFactorCurve") $ yieldCurveVal_discountFactorCurve x
]
instance Extension YieldCurveValuation PricingStructureValuation where
supertype (YieldCurveValuation a0 a1 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10) =
PricingStructureValuation a0 a1 e0 e1 e2 e3 e4 e5 e6
instance Extension YieldCurveValuation Valuation where
supertype = (supertype :: PricingStructureValuation -> Valuation)
. (supertype :: YieldCurveValuation -> PricingStructureValuation)
data ZeroRateCurve = ZeroRateCurve
{ zeroRateCurve_compoundingFrequency :: Maybe CompoundingFrequency
, zeroRateCurve_rateCurve :: Maybe TermCurve
}
deriving (Eq,Show)
instance SchemaType ZeroRateCurve where
parseSchemaType s = do
(pos,e) <- posnElement [s]
commit $ interior e $ return ZeroRateCurve
`apply` optional (parseSchemaType "compoundingFrequency")
`apply` optional (parseSchemaType "rateCurve")
schemaTypeToXML s x@ZeroRateCurve{} =
toXMLElement s []
[ maybe [] (schemaTypeToXML "compoundingFrequency") $ zeroRateCurve_compoundingFrequency x
, maybe [] (schemaTypeToXML "rateCurve") $ zeroRateCurve_rateCurve x
]
elementCreditCurve :: XMLParser CreditCurve
elementCreditCurve = parseSchemaType "creditCurve"
elementToXMLCreditCurve :: CreditCurve -> [Content ()]
elementToXMLCreditCurve = schemaTypeToXML "creditCurve"
elementCreditCurveValuation :: XMLParser CreditCurveValuation
elementCreditCurveValuation = parseSchemaType "creditCurveValuation"
elementToXMLCreditCurveValuation :: CreditCurveValuation -> [Content ()]
elementToXMLCreditCurveValuation = schemaTypeToXML "creditCurveValuation"
elementFxCurve :: XMLParser FxCurve
elementFxCurve = parseSchemaType "fxCurve"
elementToXMLFxCurve :: FxCurve -> [Content ()]
elementToXMLFxCurve = schemaTypeToXML "fxCurve"
elementFxCurveValuation :: XMLParser FxCurveValuation
elementFxCurveValuation = parseSchemaType "fxCurveValuation"
elementToXMLFxCurveValuation :: FxCurveValuation -> [Content ()]
elementToXMLFxCurveValuation = schemaTypeToXML "fxCurveValuation"
elementVolatilityMatrixValuation :: XMLParser VolatilityMatrix
elementVolatilityMatrixValuation = parseSchemaType "volatilityMatrixValuation"
elementToXMLVolatilityMatrixValuation :: VolatilityMatrix -> [Content ()]
elementToXMLVolatilityMatrixValuation = schemaTypeToXML "volatilityMatrixValuation"
elementVolatilityRepresentation :: XMLParser VolatilityRepresentation
elementVolatilityRepresentation = parseSchemaType "volatilityRepresentation"
elementToXMLVolatilityRepresentation :: VolatilityRepresentation -> [Content ()]
elementToXMLVolatilityRepresentation = schemaTypeToXML "volatilityRepresentation"
elementYieldCurve :: XMLParser YieldCurve
elementYieldCurve = parseSchemaType "yieldCurve"
elementToXMLYieldCurve :: YieldCurve -> [Content ()]
elementToXMLYieldCurve = schemaTypeToXML "yieldCurve"
elementYieldCurveValuation :: XMLParser YieldCurveValuation
elementYieldCurveValuation = parseSchemaType "yieldCurveValuation"
elementToXMLYieldCurveValuation :: YieldCurveValuation -> [Content ()]
elementToXMLYieldCurveValuation = schemaTypeToXML "yieldCurveValuation"