{-# LANGUAGE MultiParamTypeClasses, FunctionalDependencies #-} {-# OPTIONS_GHC -fno-warn-duplicate-exports #-} module Data.FpML.V53.CD ( module Data.FpML.V53.CD , module Data.FpML.V53.Shared.Option ) 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.Option -- Some hs-boot imports are required, for fwd-declaring types. data AdditionalFixedPayments = AdditionalFixedPayments { addFixedPaymen_interestShortfallReimbursement :: Maybe Xsd.Boolean -- ^ An additional Fixed Payment Event. Corresponds to the -- payment by or on behalf of the Issuer of an actual interest -- amount in respect to the reference obligation that is -- greater than the expected interest amount. ISDA 2003 Term: -- Interest Shortfall Reimbursement. , addFixedPaymen_principalShortfallReimbursement :: Maybe Xsd.Boolean -- ^ An additional Fixed Payment Event. Corresponds to the -- payment by or on behalf of the Issuer of an actual -- principal amount in respect to the reference obligation -- that is greater than the expected principal amount. ISDA -- 2003 Term: Principal Shortfall Reimbursement. , addFixedPaymen_writedownReimbursement :: Maybe Xsd.Boolean -- ^ An Additional Fixed Payment. Corresponds to the payment by -- or on behalf of the issuer of an amount in respect to the -- reference obligation in reduction of the prior writedowns. -- ISDA 2003 Term: Writedown Reimbursement. } deriving (Eq,Show) instance SchemaType AdditionalFixedPayments where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return AdditionalFixedPayments `apply` optional (parseSchemaType "interestShortfallReimbursement") `apply` optional (parseSchemaType "principalShortfallReimbursement") `apply` optional (parseSchemaType "writedownReimbursement") schemaTypeToXML s x@AdditionalFixedPayments{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "interestShortfallReimbursement") $ addFixedPaymen_interestShortfallReimbursement x , maybe [] (schemaTypeToXML "principalShortfallReimbursement") $ addFixedPaymen_principalShortfallReimbursement x , maybe [] (schemaTypeToXML "writedownReimbursement") $ addFixedPaymen_writedownReimbursement x ] data AdditionalTerm = AdditionalTerm Scheme AdditionalTermAttributes deriving (Eq,Show) data AdditionalTermAttributes = AdditionalTermAttributes { addTermAttrib_additionalTermScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType AdditionalTerm where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "additionalTermScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ AdditionalTerm v (AdditionalTermAttributes a0) schemaTypeToXML s (AdditionalTerm bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "additionalTermScheme") $ addTermAttrib_additionalTermScheme at ] $ schemaTypeToXML s bt instance Extension AdditionalTerm Scheme where supertype (AdditionalTerm s _) = s data AdjustedPaymentDates = AdjustedPaymentDates { adjustPaymentDates_adjustedPaymentDate :: Maybe Xsd.Date -- ^ The adjusted payment date. This date should already be -- adjusted for any applicable business day convention. This -- component is not intended for use in trade confirmation but -- my be specified to allow the fee structure to also serve as -- a cashflow type component (all dates the the Cashflows type -- are adjusted payment dates). , adjustPaymentDates_paymentAmount :: Maybe Money -- ^ The currency amount of the payment. } deriving (Eq,Show) instance SchemaType AdjustedPaymentDates where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return AdjustedPaymentDates `apply` optional (parseSchemaType "adjustedPaymentDate") `apply` optional (parseSchemaType "paymentAmount") schemaTypeToXML s x@AdjustedPaymentDates{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "adjustedPaymentDate") $ adjustPaymentDates_adjustedPaymentDate x , maybe [] (schemaTypeToXML "paymentAmount") $ adjustPaymentDates_paymentAmount x ] -- | CDS Basket Reference Information data BasketReferenceInformation = BasketReferenceInformation { basketRefInfo_choice0 :: (Maybe (OneOf1 ((Maybe (BasketName)),[BasketId]))) -- ^ Choice between: -- -- (1) Sequence of: -- -- * The name of the basket expressed as a free format -- string. FpML does not define usage rules for this -- element. -- -- * A CDS basket identifier , basketRefInfo_referencePool :: Maybe ReferencePool -- ^ This element contains all the reference pool items to -- define the reference entity and reference obligation(s) in -- the basket , basketRefInfo_choice2 :: (Maybe (OneOf2 ((Maybe (Xsd.PositiveInteger)),(Maybe (Xsd.PositiveInteger))) Tranche)) -- ^ Choice between: -- -- (1) Sequence of: -- -- * N th reference obligation to default triggers -- payout. -- -- * M th reference obligation to default to allow -- representation of N th to M th defaults. -- -- (2) This element contains CDS tranche terms. } deriving (Eq,Show) instance SchemaType BasketReferenceInformation where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return BasketReferenceInformation `apply` optional (oneOf' [ ("Maybe BasketName [BasketId]", fmap OneOf1 (return (,) `apply` optional (parseSchemaType "basketName") `apply` many (parseSchemaType "basketId"))) ]) `apply` optional (parseSchemaType "referencePool") `apply` optional (oneOf' [ ("Maybe Xsd.PositiveInteger Maybe Xsd.PositiveInteger", fmap OneOf2 (return (,) `apply` optional (parseSchemaType "nthToDefault") `apply` optional (parseSchemaType "mthToDefault"))) , ("Tranche", fmap TwoOf2 (parseSchemaType "tranche")) ]) schemaTypeToXML s x@BasketReferenceInformation{} = toXMLElement s [] [ maybe [] (foldOneOf1 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "basketName") a , concatMap (schemaTypeToXML "basketId") b ]) ) $ basketRefInfo_choice0 x , maybe [] (schemaTypeToXML "referencePool") $ basketRefInfo_referencePool x , maybe [] (foldOneOf2 (\ (a,b) -> concat [ maybe [] (schemaTypeToXML "nthToDefault") a , maybe [] (schemaTypeToXML "mthToDefault") b ]) (schemaTypeToXML "tranche") ) $ basketRefInfo_choice2 x ] data CalculationAmount = CalculationAmount { calcAmount_ID :: Maybe Xsd.ID , calcAmount_currency :: Currency -- ^ The currency in which an amount is denominated. , calcAmount_amount :: Xsd.Decimal -- ^ The monetary quantity in currency units. , calcAmount_step :: [Step] -- ^ A schedule of step date and value pairs. On each step date -- the associated step value becomes effective. A list of -- steps may be ordered in the document by ascending step -- date. An FpML document containing an unordered list of -- steps is still regarded as a conformant document. } deriving (Eq,Show) instance SchemaType CalculationAmount where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (CalculationAmount a0) `apply` parseSchemaType "currency" `apply` parseSchemaType "amount" `apply` many (parseSchemaType "step") schemaTypeToXML s x@CalculationAmount{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ calcAmount_ID x ] [ schemaTypeToXML "currency" $ calcAmount_currency x , schemaTypeToXML "amount" $ calcAmount_amount x , concatMap (schemaTypeToXML "step") $ calcAmount_step x ] instance Extension CalculationAmount Money where supertype (CalculationAmount a0 e0 e1 e2) = Money a0 e0 e1 instance Extension CalculationAmount MoneyBase where supertype = (supertype :: Money -> MoneyBase) . (supertype :: CalculationAmount -> Money) data CashSettlementTerms = CashSettlementTerms { cashSettlTerms_ID :: Maybe Xsd.ID , cashSettlTerms_settlementCurrency :: Maybe Currency -- ^ ISDA 2003 Term: Settlement Currency , cashSettlTerms_valuationDate :: Maybe ValuationDate -- ^ The number of business days after conditions to settlement -- have been satisfied when the calculation agent obtains a -- price quotation on the Reference Obligation for purposes of -- cash settlement. There may be one or more valuation dates. -- This is typically specified if the cash settlement amount -- is not a fixed amount. ISDA 2003 Term: Valuation Date , cashSettlTerms_valuationTime :: Maybe BusinessCenterTime -- ^ The time of day in the specified business center when the -- calculation agent seeks quotations for an amount of the -- reference obligation for purposes of cash settlement. ISDA -- 2003 Term: Valuation Time , cashSettlTerms_quotationMethod :: Maybe QuotationRateTypeEnum -- ^ The type of price quotations to be requested from dealers -- when determining the market value of the reference -- obligation for purposes of cash settlement. For example, -- Bid, Offer or Mid-market. ISDA 2003 Term: Quotation Method , cashSettlTerms_quotationAmount :: Maybe Money -- ^ In the determination of a cash settlement amount, if -- weighted average quotations are to be obtained, the -- quotation amount specifies an upper limit to the -- outstanding principal balance of the reference obligation -- for which the quote should be obtained. If not specified, -- the ISDA definitions provide for a fallback amount equal to -- the floating rate payer calculation amount. ISDA 2003 Term: -- Quotation Amount , cashSettlTerms_minimumQuotationAmount :: Maybe Money -- ^ In the determination of a cash settlement amount, if -- weighted average quotations are to be obtained, the minimum -- quotation amount specifies a minimum intended threshold -- amount of outstanding principal balance of the reference -- obligation for which the quote should be obtained. If not -- specified, the ISDA definitions provide for a fallback -- amount of the lower of either USD 1,000,000 (or its -- equivalent in the relevant obligation currency) or the -- quotation amount. ISDA 2003 Term: Minimum Quotation Amount , cashSettlTerms_dealer :: [Xsd.XsdString] -- ^ A dealer from whom quotations are obtained by the -- calculation agent on the reference obligation for purposes -- of cash settlement. ISDA 2003 Term: Dealer , cashSettlTerms_cashSettlementBusinessDays :: Maybe Xsd.NonNegativeInteger -- ^ The number of business days used in the determination of -- the cash settlement payment date. If a cash settlement -- amount is specified, the cash settlement payment date will -- be this number of business days following the calculation -- of the final price. If a cash settlement amount is not -- specified, the cash settlement payment date will be this -- number of business days after all conditions to settlement -- are satisfied. ISDA 2003 Term: Cash Settlement Date , cashSettlTerms_choice8 :: (Maybe (OneOf2 Money RestrictedPercentage)) -- ^ Choice between: -- -- (1) The amount paid by the seller to the buyer for cash -- settlement on the cash settlement date. If not -- otherwise specified, would typically be calculated as -- 100 (or the Reference Price) minus the price of the -- Reference Obligation (all expressed as a percentage) -- times Floating Rate Payer Calculation Amount. ISDA 2003 -- Term: Cash Settlement Amount. -- -- (2) Used for fixed recovery, specifies the recovery level, -- determined at contract inception, to be applied on a -- default. Used to calculate the amount paid by the -- seller to the buyer for cash settlement on the cash -- settlement date. Amount calculation is (1 minus the -- Recovery Factor) multiplied by the Floating Rate Payer -- Calculation Amount. The currency will be derived from -- the Floating Rate Payer Calculation Amount. , cashSettlTerms_fixedSettlement :: Maybe Xsd.Boolean -- ^ Used for Recovery Lock, to indicate whether fixed -- Settlement is Applicable or Not Applicable. If Buyer fails -- to deliver an effective Notice of Physical Settlement on or -- before the Buyer NOPS Cut-off Date, and If Seller fails to -- deliver an effective Seller NOPS on or before the Seller -- NOPS Cut-off Date, then either: (a) if Fixed Settlement is -- specified in the related Confirmation as not applicable, -- then the Seller NOPS Cut-off Date shall be the Termination -- Date; or (b) if Fixed Settlement is specified in the -- related Confirmation as applicable, then: (i) if the Fixed -- Settlement Amount is a positive number, Seller shall, -- subject to Section 3.1 (except for the requirement of -- satisfaction of the Notice of Physical Settlement Condition -- to Settlement), pay the Fixed Settlement Amount to Buyer on -- the Fixed Settlement Payment Date; and (ii) if the Fixed -- Settlement Amount is a negative number, Buyer shall, -- subject to Section 3.1 (except for the requirement of -- satisfaction of the Notice of Physical Settlement Condition -- to Settlement), pay the absolute value of the Fixed -- Settlement Amount to Seller on the Fixed Settlement Payment -- Date. , cashSettlTerms_accruedInterest :: Maybe Xsd.Boolean -- ^ Indicates whether accrued interest is included (true) or -- not (false). For cash settlement this specifies whether -- quotations should be obtained inclusive or not of accrued -- interest. For physical settlement this specifies whether -- the buyer should deliver the obligation with an outstanding -- principal balance that includes or excludes accrued -- interest. ISDA 2003 Term: Include/Exclude Accrued Interest , cashSettlTerms_valuationMethod :: Maybe ValuationMethodEnum -- ^ The ISDA defined methodology for determining the final -- price of the reference obligation for purposes of cash -- settlement. (ISDA 2003 Term: Valuation Method). For -- example, Market, Highest etc. } deriving (Eq,Show) instance SchemaType CashSettlementTerms where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (CashSettlementTerms a0) `apply` optional (parseSchemaType "settlementCurrency") `apply` optional (parseSchemaType "valuationDate") `apply` optional (parseSchemaType "valuationTime") `apply` optional (parseSchemaType "quotationMethod") `apply` optional (parseSchemaType "quotationAmount") `apply` optional (parseSchemaType "minimumQuotationAmount") `apply` many (parseSchemaType "dealer") `apply` optional (parseSchemaType "cashSettlementBusinessDays") `apply` optional (oneOf' [ ("Money", fmap OneOf2 (parseSchemaType "cashSettlementAmount")) , ("RestrictedPercentage", fmap TwoOf2 (parseSchemaType "recoveryFactor")) ]) `apply` optional (parseSchemaType "fixedSettlement") `apply` optional (parseSchemaType "accruedInterest") `apply` optional (parseSchemaType "valuationMethod") schemaTypeToXML s x@CashSettlementTerms{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ cashSettlTerms_ID x ] [ maybe [] (schemaTypeToXML "settlementCurrency") $ cashSettlTerms_settlementCurrency x , maybe [] (schemaTypeToXML "valuationDate") $ cashSettlTerms_valuationDate x , maybe [] (schemaTypeToXML "valuationTime") $ cashSettlTerms_valuationTime x , maybe [] (schemaTypeToXML "quotationMethod") $ cashSettlTerms_quotationMethod x , maybe [] (schemaTypeToXML "quotationAmount") $ cashSettlTerms_quotationAmount x , maybe [] (schemaTypeToXML "minimumQuotationAmount") $ cashSettlTerms_minimumQuotationAmount x , concatMap (schemaTypeToXML "dealer") $ cashSettlTerms_dealer x , maybe [] (schemaTypeToXML "cashSettlementBusinessDays") $ cashSettlTerms_cashSettlementBusinessDays x , maybe [] (foldOneOf2 (schemaTypeToXML "cashSettlementAmount") (schemaTypeToXML "recoveryFactor") ) $ cashSettlTerms_choice8 x , maybe [] (schemaTypeToXML "fixedSettlement") $ cashSettlTerms_fixedSettlement x , maybe [] (schemaTypeToXML "accruedInterest") $ cashSettlTerms_accruedInterest x , maybe [] (schemaTypeToXML "valuationMethod") $ cashSettlTerms_valuationMethod x ] instance Extension CashSettlementTerms SettlementTerms where supertype (CashSettlementTerms a0 e0 e1 e2 e3 e4 e5 e6 e7 e8 e9 e10 e11) = SettlementTerms a0 e0 data CreditDefaultSwap = CreditDefaultSwap { creditDefaultSwap_ID :: Maybe Xsd.ID , creditDefaultSwap_primaryAssetClass :: Maybe AssetClass -- ^ A classification of the most important risk class of the -- trade. FpML defines a simple asset class categorization -- using a coding scheme. , creditDefaultSwap_secondaryAssetClass :: [AssetClass] -- ^ A classification of additional risk classes of the trade, -- if any. FpML defines a simple asset class categorization -- using a coding scheme. , creditDefaultSwap_productType :: [ProductType] -- ^ A classification of the type of product. FpML defines a -- simple product categorization using a coding scheme. , creditDefaultSwap_productId :: [ProductId] -- ^ A product reference identifier. The product ID is an -- identifier that describes the key economic characteristics -- of the trade type, with the exception of concepts such as -- size (notional, quantity, number of units) and price (fixed -- rate, strike, etc.) that are negotiated for each -- transaction. It can be used to hold identifiers such as the -- "UPI" (universal product identifier) required by certain -- regulatory reporting rules. It can also be used to hold -- identifiers of benchmark products or product temnplates -- used by certain trading systems or facilities. FpML does -- not define the domain values associated with this element. -- Note that the domain values for this element are not -- strictly an enumerated list. , creditDefaultSwap_generalTerms :: GeneralTerms -- ^ This element contains all the data that appears in the -- section entitled "1. General Terms" in the 2003 ISDA Credit -- Derivatives Confirmation. , creditDefaultSwap_feeLeg :: FeeLeg -- ^ This element contains all the terms relevant to defining -- the fixed amounts/payments per the applicable ISDA -- definitions. , creditDefaultSwap_protectionTerms :: [ProtectionTerms] -- ^ This element contains all the terms relevant to defining -- the applicable floating rate payer calculation amount, -- credit events and associated conditions to settlement, and -- reference obligations. , creditDefaultSwap_choice7 :: [OneOf2 CashSettlementTerms PhysicalSettlementTerms] -- ^ Choice between: -- -- (1) This element contains all the ISDA terms relevant to -- cash settlement for when cash settlement is applicable. -- ISDA 2003 Term: Cash Settlement -- -- (2) This element contains all the ISDA terms relevant to -- physical settlement for when physical settlement is -- applicable. ISDA 2003 Term: Physical Settlement } deriving (Eq,Show) instance SchemaType CreditDefaultSwap where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (CreditDefaultSwap a0) `apply` optional (parseSchemaType "primaryAssetClass") `apply` many (parseSchemaType "secondaryAssetClass") `apply` many (parseSchemaType "productType") `apply` many (parseSchemaType "productId") `apply` parseSchemaType "generalTerms" `apply` parseSchemaType "feeLeg" `apply` many1 (parseSchemaType "protectionTerms") `apply` many (oneOf' [ ("CashSettlementTerms", fmap OneOf2 (parseSchemaType "cashSettlementTerms")) , ("PhysicalSettlementTerms", fmap TwoOf2 (parseSchemaType "physicalSettlementTerms")) ]) schemaTypeToXML s x@CreditDefaultSwap{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ creditDefaultSwap_ID x ] [ maybe [] (schemaTypeToXML "primaryAssetClass") $ creditDefaultSwap_primaryAssetClass x , concatMap (schemaTypeToXML "secondaryAssetClass") $ creditDefaultSwap_secondaryAssetClass x , concatMap (schemaTypeToXML "productType") $ creditDefaultSwap_productType x , concatMap (schemaTypeToXML "productId") $ creditDefaultSwap_productId x , schemaTypeToXML "generalTerms" $ creditDefaultSwap_generalTerms x , schemaTypeToXML "feeLeg" $ creditDefaultSwap_feeLeg x , concatMap (schemaTypeToXML "protectionTerms") $ creditDefaultSwap_protectionTerms x , concatMap (foldOneOf2 (schemaTypeToXML "cashSettlementTerms") (schemaTypeToXML "physicalSettlementTerms") ) $ creditDefaultSwap_choice7 x ] instance Extension CreditDefaultSwap Product where supertype v = Product_CreditDefaultSwap v -- | A complex type to support the credit default swap option. data CreditDefaultSwapOption = CreditDefaultSwapOption { creditDefaultSwapOption_ID :: Maybe Xsd.ID , creditDefaultSwapOption_primaryAssetClass :: Maybe AssetClass -- ^ A classification of the most important risk class of the -- trade. FpML defines a simple asset class categorization -- using a coding scheme. , creditDefaultSwapOption_secondaryAssetClass :: [AssetClass] -- ^ A classification of additional risk classes of the trade, -- if any. FpML defines a simple asset class categorization -- using a coding scheme. , creditDefaultSwapOption_productType :: [ProductType] -- ^ A classification of the type of product. FpML defines a -- simple product categorization using a coding scheme. , creditDefaultSwapOption_productId :: [ProductId] -- ^ A product reference identifier. The product ID is an -- identifier that describes the key economic characteristics -- of the trade type, with the exception of concepts such as -- size (notional, quantity, number of units) and price (fixed -- rate, strike, etc.) that are negotiated for each -- transaction. It can be used to hold identifiers such as the -- "UPI" (universal product identifier) required by certain -- regulatory reporting rules. It can also be used to hold -- identifiers of benchmark products or product temnplates -- used by certain trading systems or facilities. FpML does -- not define the domain values associated with this element. -- Note that the domain values for this element are not -- strictly an enumerated list. , creditDefaultSwapOption_buyerPartyReference :: Maybe PartyReference -- ^ A reference to the party that buys this instrument, ie. -- pays for this instrument and receives the rights defined by -- it. See 2000 ISDA definitions Article 11.1 (b). In the case -- of FRAs this the fixed rate payer. , creditDefaultSwapOption_buyerAccountReference :: Maybe AccountReference -- ^ A reference to the account that buys this instrument. , creditDefaultSwapOption_sellerPartyReference :: Maybe PartyReference -- ^ A reference to the party that sells ("writes") this -- instrument, i.e. that grants the rights defined by this -- instrument and in return receives a payment for it. See -- 2000 ISDA definitions Article 11.1 (a). In the case of FRAs -- this is the floating rate payer. , creditDefaultSwapOption_sellerAccountReference :: Maybe AccountReference -- ^ A reference to the account that sells this instrument. , creditDefaultSwapOption_optionType :: OptionTypeEnum -- ^ The type of option transaction. From a usage standpoint, -- put/call is the default option type, while payer/receiver -- indicator is used for options index credit default swaps, -- consistently with the industry practice. Straddle is used -- for the case of straddle strategy, that combine a call and -- a put with the same strike. , creditDefaultSwapOption_premium :: Premium -- ^ The option premium payable by the buyer to the seller. , creditDefaultSwapOption_exercise :: Exercise -- ^ An placeholder for the actual option exercise definitions. , creditDefaultSwapOption_exerciseProcedure :: Maybe ExerciseProcedure -- ^ A set of parameters defining procedures associated with the -- exercise. , creditDefaultSwapOption_feature :: Maybe OptionFeature -- ^ An Option feature such as quanto, asian, barrier, knock. , creditDefaultSwapOption_choice13 :: (Maybe (OneOf2 NotionalAmountReference Money)) -- ^ A choice between an explicit representation of the notional -- amount, or a reference to a notional amount defined -- elsewhere in this document. -- -- Choice between: -- -- (1) notionalReference -- -- (2) notionalAmount , creditDefaultSwapOption_optionEntitlement :: Maybe PositiveDecimal -- ^ The number of units of underlyer per option comprised in -- the option transaction. , creditDefaultSwapOption_entitlementCurrency :: Maybe Currency -- ^ TODO , creditDefaultSwapOption_numberOfOptions :: Maybe PositiveDecimal -- ^ The number of options comprised in the option transaction. , creditDefaultSwapOption_settlementType :: Maybe SettlementTypeEnum , creditDefaultSwapOption_settlementDate :: Maybe AdjustableOrRelativeDate , creditDefaultSwapOption_choice19 :: (Maybe (OneOf2 Money Currency)) -- ^ Choice between: -- -- (1) Settlement Amount -- -- (2) Settlement Currency for use where the Settlement Amount -- cannot be known in advance , creditDefaultSwapOption_strike :: CreditOptionStrike -- ^ Specifies the strike of the option on credit default swap. , creditDefaultSwapOption_creditDefaultSwap :: CreditDefaultSwap } deriving (Eq,Show) instance SchemaType CreditDefaultSwapOption where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (CreditDefaultSwapOption 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` parseSchemaType "optionType" `apply` parseSchemaType "premium" `apply` elementExercise `apply` optional (parseSchemaType "exerciseProcedure") `apply` optional (parseSchemaType "feature") `apply` optional (oneOf' [ ("NotionalAmountReference", fmap OneOf2 (parseSchemaType "notionalReference")) , ("Money", fmap TwoOf2 (parseSchemaType "notionalAmount")) ]) `apply` optional (parseSchemaType "optionEntitlement") `apply` optional (parseSchemaType "entitlementCurrency") `apply` optional (parseSchemaType "numberOfOptions") `apply` optional (parseSchemaType "settlementType") `apply` optional (parseSchemaType "settlementDate") `apply` optional (oneOf' [ ("Money", fmap OneOf2 (parseSchemaType "settlementAmount")) , ("Currency", fmap TwoOf2 (parseSchemaType "settlementCurrency")) ]) `apply` parseSchemaType "strike" `apply` parseSchemaType "creditDefaultSwap" schemaTypeToXML s x@CreditDefaultSwapOption{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ creditDefaultSwapOption_ID x ] [ maybe [] (schemaTypeToXML "primaryAssetClass") $ creditDefaultSwapOption_primaryAssetClass x , concatMap (schemaTypeToXML "secondaryAssetClass") $ creditDefaultSwapOption_secondaryAssetClass x , concatMap (schemaTypeToXML "productType") $ creditDefaultSwapOption_productType x , concatMap (schemaTypeToXML "productId") $ creditDefaultSwapOption_productId x , maybe [] (schemaTypeToXML "buyerPartyReference") $ creditDefaultSwapOption_buyerPartyReference x , maybe [] (schemaTypeToXML "buyerAccountReference") $ creditDefaultSwapOption_buyerAccountReference x , maybe [] (schemaTypeToXML "sellerPartyReference") $ creditDefaultSwapOption_sellerPartyReference x , maybe [] (schemaTypeToXML "sellerAccountReference") $ creditDefaultSwapOption_sellerAccountReference x , schemaTypeToXML "optionType" $ creditDefaultSwapOption_optionType x , schemaTypeToXML "premium" $ creditDefaultSwapOption_premium x , elementToXMLExercise $ creditDefaultSwapOption_exercise x , maybe [] (schemaTypeToXML "exerciseProcedure") $ creditDefaultSwapOption_exerciseProcedure x , maybe [] (schemaTypeToXML "feature") $ creditDefaultSwapOption_feature x , maybe [] (foldOneOf2 (schemaTypeToXML "notionalReference") (schemaTypeToXML "notionalAmount") ) $ creditDefaultSwapOption_choice13 x , maybe [] (schemaTypeToXML "optionEntitlement") $ creditDefaultSwapOption_optionEntitlement x , maybe [] (schemaTypeToXML "entitlementCurrency") $ creditDefaultSwapOption_entitlementCurrency x , maybe [] (schemaTypeToXML "numberOfOptions") $ creditDefaultSwapOption_numberOfOptions x , maybe [] (schemaTypeToXML "settlementType") $ creditDefaultSwapOption_settlementType x , maybe [] (schemaTypeToXML "settlementDate") $ creditDefaultSwapOption_settlementDate x , maybe [] (foldOneOf2 (schemaTypeToXML "settlementAmount") (schemaTypeToXML "settlementCurrency") ) $ creditDefaultSwapOption_choice19 x , schemaTypeToXML "strike" $ creditDefaultSwapOption_strike x , schemaTypeToXML "creditDefaultSwap" $ creditDefaultSwapOption_creditDefaultSwap x ] instance Extension CreditDefaultSwapOption OptionBaseExtended where supertype v = OptionBaseExtended_CreditDefaultSwapOption v instance Extension CreditDefaultSwapOption OptionBase where supertype = (supertype :: OptionBaseExtended -> OptionBase) . (supertype :: CreditDefaultSwapOption -> OptionBaseExtended) instance Extension CreditDefaultSwapOption Option where supertype = (supertype :: OptionBase -> Option) . (supertype :: OptionBaseExtended -> OptionBase) . (supertype :: CreditDefaultSwapOption -> OptionBaseExtended) instance Extension CreditDefaultSwapOption Product where supertype = (supertype :: Option -> Product) . (supertype :: OptionBase -> Option) . (supertype :: OptionBaseExtended -> OptionBase) . (supertype :: CreditDefaultSwapOption -> OptionBaseExtended) -- | A complex type to specify the strike of a credit swaption -- or a credit default swap option. data CreditOptionStrike = CreditOptionStrike { creditOptionStrike_choice0 :: (Maybe (OneOf3 Xsd.Decimal Xsd.Decimal FixedRateReference)) -- ^ Choice between: -- -- (1) The strike of a credit default swap option or credit -- swaption when expressed as a spread per annum. -- -- (2) The strike of a credit default swap option or credit -- swaption when expressed as in reference to the price of -- the underlying obligation(s) or index. -- -- (3) The strike of a credit default swap option or credit -- swaption when expressed in reference to the spread of -- the underlying swap (typical practice in the case of -- single name swaps). } deriving (Eq,Show) instance SchemaType CreditOptionStrike where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return CreditOptionStrike `apply` optional (oneOf' [ ("Xsd.Decimal", fmap OneOf3 (parseSchemaType "spread")) , ("Xsd.Decimal", fmap TwoOf3 (parseSchemaType "price")) , ("FixedRateReference", fmap ThreeOf3 (parseSchemaType "strikeReference")) ]) schemaTypeToXML s x@CreditOptionStrike{} = toXMLElement s [] [ maybe [] (foldOneOf3 (schemaTypeToXML "spread") (schemaTypeToXML "price") (schemaTypeToXML "strikeReference") ) $ creditOptionStrike_choice0 x ] data DeliverableObligations = DeliverableObligations { delivOblig_accruedInterest :: Maybe Xsd.Boolean -- ^ Indicates whether accrued interest is included (true) or -- not (false). For cash settlement this specifies whether -- quotations should be obtained inclusive or not of accrued -- interest. For physical settlement this specifies whether -- the buyer should deliver the obligation with an outstanding -- principal balance that includes or excludes accrued -- interest. ISDA 2003 Term: Include/Exclude Accrued Interest , delivOblig_category :: Maybe ObligationCategoryEnum -- ^ Used in both obligations and deliverable obligations to -- represent a class or type of securities which apply. ISDA -- 2003 Term: Obligation Category/Deliverable Obligation -- Category , delivOblig_notSubordinated :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. An -- obligation that ranks at least equal with the most senior -- Reference Obligation in priority of payment or, if no -- Reference Obligation is specified in the related -- Confirmation, the obligations of the Reference Entity that -- are senior. ISDA 2003 Term: Not Subordinated , delivOblig_specifiedCurrency :: Maybe SpecifiedCurrency -- ^ An obligation and deliverable obligation characteristic. -- The currency or currencies in which an obligation or -- deliverable obligation must be payable. ISDA 2003 Term: -- Specified Currency , delivOblig_notSovereignLender :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Any obligation that is not primarily (majority) owed to a -- Sovereign or Supranational Organization. ISDA 2003 Term: -- Not Sovereign Lender , delivOblig_notDomesticCurrency :: Maybe NotDomesticCurrency -- ^ An obligation and deliverable obligation characteristic. -- Any obligation that is payable in any currency other than -- the domestic currency. Domestic currency is either the -- currency so specified or, if no currency is specified, the -- currency of (a) the reference entity, if the reference -- entity is a sovereign, or (b) the jurisdiction in which the -- relevant reference entity is organised, if the reference -- entity is not a sovereign. ISDA 2003 Term: Not Domestic -- Currency , delivOblig_notDomesticLaw :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. If -- the reference entity is a Sovereign, this means any -- obligation that is not subject to the laws of the reference -- entity. If the reference entity is not a sovereign, this -- means any obligation that is not subject to the laws of the -- jurisdiction of the reference entity. ISDA 2003 Term: Not -- Domestic Law , delivOblig_listed :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Indicates whether or not the obligation is quoted, listed -- or ordinarily purchased and sold on an exchange. ISDA 2003 -- Term: Listed , delivOblig_notContingent :: Maybe Xsd.Boolean -- ^ A deliverable obligation characteristic. In essence Not -- Contingent means the repayment of principal cannot be -- dependant on a formula/index, i.e. to prevent the risk of -- being delivered an instrument that may never pay any -- element of principal, and to ensure that the obligation is -- interest bearing (on a regular schedule). ISDA 2003 Term: -- Not Contingent , delivOblig_notDomesticIssuance :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Any obligation other than an obligation that was intended -- to be offered for sale primarily in the domestic market of -- the relevant Reference Entity. This specifies that the -- obligation must be an internationally recognized bond. ISDA -- 2003 Term: Not Domestic Issuance , delivOblig_assignableLoan :: Maybe PCDeliverableObligationCharac -- ^ A deliverable obligation characteristic. A loan that is -- freely assignable to a bank or financial institution -- without the consent of the Reference Entity or the -- guarantor, if any, of the loan (or the consent of the -- applicable borrower if a Reference Entity is guaranteeing -- the loan) or any agent. ISDA 2003 Term: Assignable Loan , delivOblig_consentRequiredLoan :: Maybe PCDeliverableObligationCharac -- ^ A deliverable obligation characteristic. A loan that is -- capable of being assigned with the consent of the Reference -- Entity or the guarantor, if any, of the loan or any agent. -- ISDA 2003 Term: Consent Required Loan , delivOblig_directLoanParticipation :: Maybe LoanParticipation -- ^ A deliverable obligation characteristic. A loan with a -- participation agreement whereby the buyer is capable of -- creating, or procuring the creation of, a contractual right -- in favour of the seller that provides the seller with -- recourse to the participation seller for a specified share -- in any payments due under the relevant loan which are -- received by the participation seller. ISDA 2003 Term: -- Direct Loan Participation , delivOblig_transferable :: Maybe Xsd.Boolean -- ^ A deliverable obligation characteristic. An obligation that -- is transferable to institutional investors without any -- contractual, statutory or regulatory restrictions. ISDA -- 2003 Term: Transferable , delivOblig_maximumMaturity :: Maybe Period -- ^ A deliverable obligation characteristic. An obligation that -- has a remaining maturity from the Physical Settlement Date -- of not greater than the period specified. ISDA 2003 Term: -- Maximum Maturity , delivOblig_acceleratedOrMatured :: Maybe Xsd.Boolean -- ^ A deliverable obligation characteristic. An obligation at -- time of default is due to mature and due to be repaid, or -- as a result of downgrade/bankruptcy is due to be repaid as -- a result of an acceleration clause. ISDA 2003 Term: -- Accelerated or Matured , delivOblig_notBearer :: Maybe Xsd.Boolean -- ^ A deliverable obligation characteristic. Any obligation -- that is not a bearer instrument. This applies to Bonds only -- and is meant to avoid tax, fraud and security/delivery -- provisions that can potentially be associated with Bearer -- Bonds. ISDA 2003 Term: Not Bearer , delivOblig_choice17 :: (Maybe (OneOf3 Xsd.Boolean Xsd.Boolean Xsd.Boolean)) -- ^ Choice between: -- -- (1) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: Full Faith and Credit -- Obligation Liability -- -- (2) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: General Fund Obligation -- Liability -- -- (3) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: Revenue Obligation Liability , delivOblig_indirectLoanParticipation :: Maybe LoanParticipation -- ^ ISDA 1999 Term: Indirect Loan Participation. NOTE: Only -- applicable as a deliverable obligation under ISDA Credit -- 1999. , delivOblig_excluded :: Maybe Xsd.XsdString -- ^ A free format string to specify any excluded obligations or -- deliverable obligations, as the case may be, of the -- reference entity or excluded types of obligations or -- deliverable obligations. ISDA 2003 Term: Excluded -- Obligations/Excluded Deliverable Obligations , delivOblig_othReferenceEntityObligations :: Maybe Xsd.XsdString -- ^ This element is used to specify any other obligations of a -- reference entity in both obligations and deliverable -- obligations. The obligations can be specified free-form. -- ISDA 2003 Term: Other Obligations of a Reference Entity } deriving (Eq,Show) instance SchemaType DeliverableObligations where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return DeliverableObligations `apply` optional (parseSchemaType "accruedInterest") `apply` optional (parseSchemaType "category") `apply` optional (parseSchemaType "notSubordinated") `apply` optional (parseSchemaType "specifiedCurrency") `apply` optional (parseSchemaType "notSovereignLender") `apply` optional (parseSchemaType "notDomesticCurrency") `apply` optional (parseSchemaType "notDomesticLaw") `apply` optional (parseSchemaType "listed") `apply` optional (parseSchemaType "notContingent") `apply` optional (parseSchemaType "notDomesticIssuance") `apply` optional (parseSchemaType "assignableLoan") `apply` optional (parseSchemaType "consentRequiredLoan") `apply` optional (parseSchemaType "directLoanParticipation") `apply` optional (parseSchemaType "transferable") `apply` optional (parseSchemaType "maximumMaturity") `apply` optional (parseSchemaType "acceleratedOrMatured") `apply` optional (parseSchemaType "notBearer") `apply` optional (oneOf' [ ("Xsd.Boolean", fmap OneOf3 (parseSchemaType "fullFaithAndCreditObLiability")) , ("Xsd.Boolean", fmap TwoOf3 (parseSchemaType "generalFundObligationLiability")) , ("Xsd.Boolean", fmap ThreeOf3 (parseSchemaType "revenueObligationLiability")) ]) `apply` optional (parseSchemaType "indirectLoanParticipation") `apply` optional (parseSchemaType "excluded") `apply` optional (parseSchemaType "othReferenceEntityObligations") schemaTypeToXML s x@DeliverableObligations{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "accruedInterest") $ delivOblig_accruedInterest x , maybe [] (schemaTypeToXML "category") $ delivOblig_category x , maybe [] (schemaTypeToXML "notSubordinated") $ delivOblig_notSubordinated x , maybe [] (schemaTypeToXML "specifiedCurrency") $ delivOblig_specifiedCurrency x , maybe [] (schemaTypeToXML "notSovereignLender") $ delivOblig_notSovereignLender x , maybe [] (schemaTypeToXML "notDomesticCurrency") $ delivOblig_notDomesticCurrency x , maybe [] (schemaTypeToXML "notDomesticLaw") $ delivOblig_notDomesticLaw x , maybe [] (schemaTypeToXML "listed") $ delivOblig_listed x , maybe [] (schemaTypeToXML "notContingent") $ delivOblig_notContingent x , maybe [] (schemaTypeToXML "notDomesticIssuance") $ delivOblig_notDomesticIssuance x , maybe [] (schemaTypeToXML "assignableLoan") $ delivOblig_assignableLoan x , maybe [] (schemaTypeToXML "consentRequiredLoan") $ delivOblig_consentRequiredLoan x , maybe [] (schemaTypeToXML "directLoanParticipation") $ delivOblig_directLoanParticipation x , maybe [] (schemaTypeToXML "transferable") $ delivOblig_transferable x , maybe [] (schemaTypeToXML "maximumMaturity") $ delivOblig_maximumMaturity x , maybe [] (schemaTypeToXML "acceleratedOrMatured") $ delivOblig_acceleratedOrMatured x , maybe [] (schemaTypeToXML "notBearer") $ delivOblig_notBearer x , maybe [] (foldOneOf3 (schemaTypeToXML "fullFaithAndCreditObLiability") (schemaTypeToXML "generalFundObligationLiability") (schemaTypeToXML "revenueObligationLiability") ) $ delivOblig_choice17 x , maybe [] (schemaTypeToXML "indirectLoanParticipation") $ delivOblig_indirectLoanParticipation x , maybe [] (schemaTypeToXML "excluded") $ delivOblig_excluded x , maybe [] (schemaTypeToXML "othReferenceEntityObligations") $ delivOblig_othReferenceEntityObligations x ] -- | Defines a coding scheme of the entity types defined in the -- ISDA First to Default documentation. data EntityType = EntityType Scheme EntityTypeAttributes deriving (Eq,Show) data EntityTypeAttributes = EntityTypeAttributes { entityTypeAttrib_entityTypeScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType EntityType where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "entityTypeScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ EntityType v (EntityTypeAttributes a0) schemaTypeToXML s (EntityType bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "entityTypeScheme") $ entityTypeAttrib_entityTypeScheme at ] $ schemaTypeToXML s bt instance Extension EntityType Scheme where supertype (EntityType s _) = s data FeeLeg = FeeLeg { feeLeg_ID :: Maybe Xsd.ID , feeLeg_initialPayment :: Maybe InitialPayment -- ^ Specifies a single fixed payment that is payable by the -- payer to the receiver on the initial payment date. The -- fixed payment to be paid is specified in terms of a known -- currency amount. This element should be used for CDS Index -- trades and can be used for CDS trades where it is necessary -- to represent a payment from Seller to Buyer. For CDS trades -- where a payment is to be made from Buyer to Seller the -- feeLeg/singlePayment structure must be used. , feeLeg_singlePayment :: [SinglePayment] -- ^ Specifies a single fixed amount that is payable by the -- buyer to the seller on the fixed rate payer payment date. -- The fixed amount to be paid is specified in terms of a -- known currency amount. , feeLeg_periodicPayment :: Maybe PeriodicPayment -- ^ Specifies a periodic schedule of fixed amounts that are -- payable by the buyer to the seller on the fixed rate payer -- payment dates. The fixed amount to be paid on each payment -- date can be specified in terms of a known currency amount -- or as an amount calculated on a formula basis by reference -- to a per annum fixed rate. The applicable business day -- convention and business day for adjusting any fixed rate -- payer payment date if it would otherwise fall on a day that -- is not a business day are those specified in the -- dateAdjustments element within the generalTerms component. -- ISDA 2003 Term: , feeLeg_marketFixedRate :: Maybe Xsd.Decimal -- ^ An optional element that only has meaning in a credit index -- trade. This element contains the credit spread ("fair -- value") at which the trade was executed. Unlike the -- fixedRate of an index, the marketFixedRate varies over the -- life of the index depending on market conditions. The -- marketFixedRate is the price of the index as quoted by -- trading desks. , feeLeg_paymentDelay :: Maybe Xsd.Boolean -- ^ Applicable to CDS on MBS to specify whether payment delays -- are applicable to the fixed Amount. RMBS typically have a -- payment delay of 5 days between the coupon date of the -- reference obligation and the payment date of the synthetic -- swap. CMBS do not, on the other hand, with both payment -- dates being on the 25th of each month. , feeLeg_initialPoints :: Maybe Xsd.Decimal -- ^ An optional element that contains the up-front points -- expressed as a percentage of the notional. An initialPoints -- value of 5% would be represented as 0.05. The initialPoints -- element is an alternative to marketFixedRate in quoting the -- traded level of a trade. When initialPoints is used, the -- traded level is the sum of fixedRate and initialPoints. The -- initialPoints is one of the items that are factored into -- the initialPayment calculation and is payable by the Buyer -- to the Seller. Note that initialPoints and marketFixedRate -- may both be present in the same document when both implied -- values are desired. , feeLeg_quotationStyle :: Maybe QuotationStyleEnum -- ^ The type of quotation that was used between the trading -- desks. The purpose of this element is to indicate the -- actual quotation style that was used to quote this trade -- which may not be apparent when both marketFixedRate and -- initialPoints are included in the document. When -- quotationStyle is ‘PointsUpFront’, the initialPoints -- element should be populated. When quotationStyle is -- ‘TradedSpread’, the marketFixedRate element should be -- populated. } deriving (Eq,Show) instance SchemaType FeeLeg where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (FeeLeg a0) `apply` optional (parseSchemaType "initialPayment") `apply` many (parseSchemaType "singlePayment") `apply` optional (parseSchemaType "periodicPayment") `apply` optional (parseSchemaType "marketFixedRate") `apply` optional (parseSchemaType "paymentDelay") `apply` optional (parseSchemaType "initialPoints") `apply` optional (parseSchemaType "quotationStyle") schemaTypeToXML s x@FeeLeg{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ feeLeg_ID x ] [ maybe [] (schemaTypeToXML "initialPayment") $ feeLeg_initialPayment x , concatMap (schemaTypeToXML "singlePayment") $ feeLeg_singlePayment x , maybe [] (schemaTypeToXML "periodicPayment") $ feeLeg_periodicPayment x , maybe [] (schemaTypeToXML "marketFixedRate") $ feeLeg_marketFixedRate x , maybe [] (schemaTypeToXML "paymentDelay") $ feeLeg_paymentDelay x , maybe [] (schemaTypeToXML "initialPoints") $ feeLeg_initialPoints x , maybe [] (schemaTypeToXML "quotationStyle") $ feeLeg_quotationStyle x ] instance Extension FeeLeg Leg where supertype v = Leg_FeeLeg v data FixedAmountCalculation = FixedAmountCalculation { fixedAmountCalc_calculationAmount :: Maybe CalculationAmount -- ^ The notional amount used in the calculation of fixed -- amounts where an amount is calculated on a formula basis, -- i.e. fixed amount = fixed rate payer calculation amount x -- fixed rate x fixed rate day count fraction. ISDA 2003 Term: -- Fixed Rate Payer Calculation Amount. , fixedAmountCalc_fixedRate :: FixedRate -- ^ The calculation period fixed rate. A per annum rate, -- expressed as a decimal. A fixed rate of 5% would be -- represented as 0.05. , fixedAmountCalc_dayCountFraction :: Maybe DayCountFraction -- ^ The day count fraction. ISDA 2003 Term: Fixed Rate Day -- Count Fraction. } deriving (Eq,Show) instance SchemaType FixedAmountCalculation where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return FixedAmountCalculation `apply` optional (parseSchemaType "calculationAmount") `apply` parseSchemaType "fixedRate" `apply` optional (parseSchemaType "dayCountFraction") schemaTypeToXML s x@FixedAmountCalculation{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "calculationAmount") $ fixedAmountCalc_calculationAmount x , schemaTypeToXML "fixedRate" $ fixedAmountCalc_fixedRate x , maybe [] (schemaTypeToXML "dayCountFraction") $ fixedAmountCalc_dayCountFraction x ] -- | The calculation period fixed rate. A per annum rate, -- expressed as a decimal. A fixed rate of 5% would be -- represented as 0.05. data FixedRate = FixedRate Xsd.Decimal FixedRateAttributes deriving (Eq,Show) data FixedRateAttributes = FixedRateAttributes { fixedRateAttrib_ID :: Maybe Xsd.ID } deriving (Eq,Show) instance SchemaType FixedRate where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "id" e pos reparse [CElem e pos] v <- parseSchemaType s return $ FixedRate v (FixedRateAttributes a0) schemaTypeToXML s (FixedRate bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "id") $ fixedRateAttrib_ID at ] $ schemaTypeToXML s bt instance Extension FixedRate Xsd.Decimal where supertype (FixedRate s _) = s data FixedRateReference = FixedRateReference { fixedRateRef_href :: Xsd.IDREF } deriving (Eq,Show) instance SchemaType FixedRateReference where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- getAttribute "href" e pos commit $ interior e $ return (FixedRateReference a0) schemaTypeToXML s x@FixedRateReference{} = toXMLElement s [ toXMLAttribute "href" $ fixedRateRef_href x ] [] instance Extension FixedRateReference Reference where supertype v = Reference_FixedRateReference v data FloatingAmountEvents = FloatingAmountEvents { floatAmountEvents_failureToPayPrincipal :: Maybe Xsd.Boolean -- ^ A floating rate payment event. Corresponds to the failure -- by the Reference Entity to pay an expected principal amount -- or the payment of an actual principal amount that is less -- than the expected principal amount. ISDA 2003 Term: Failure -- to Pay Principal. , floatAmountEvents_interestShortfall :: Maybe InterestShortFall -- ^ A floating rate payment event. With respect to any -- Reference Obligation Payment Date, either (a) the -- non-payment of an Expected Interest Amount or (b) the -- payment of an Actual Interest Amount that is less than the -- Expected Interest Amount. ISDA 2003 Term: Interest -- Shortfall. , floatAmountEvents_writedown :: Maybe Xsd.Boolean -- ^ A floating rate payment event. Results from the fact that -- the underlyer writes down its outstanding principal amount. -- ISDA 2003 Term: Writedown. , floatAmountEvents_impliedWritedown :: Maybe Xsd.Boolean -- ^ A floating rate payment event. Results from the fact that -- losses occur to the underlying instruments that do not -- result in reductions of the outstanding principal of the -- reference obligation. , floatAmountEvents_floatingAmountProvisions :: Maybe FloatingAmountProvisions -- ^ Specifies the floating amount provisions associated with -- the floatingAmountEvents. , floatAmountEvents_additionalFixedPayments :: Maybe AdditionalFixedPayments -- ^ Specifies the events that will give rise to the payment a -- additional fixed payments. } deriving (Eq,Show) instance SchemaType FloatingAmountEvents where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return FloatingAmountEvents `apply` optional (parseSchemaType "failureToPayPrincipal") `apply` optional (parseSchemaType "interestShortfall") `apply` optional (parseSchemaType "writedown") `apply` optional (parseSchemaType "impliedWritedown") `apply` optional (parseSchemaType "floatingAmountProvisions") `apply` optional (parseSchemaType "additionalFixedPayments") schemaTypeToXML s x@FloatingAmountEvents{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "failureToPayPrincipal") $ floatAmountEvents_failureToPayPrincipal x , maybe [] (schemaTypeToXML "interestShortfall") $ floatAmountEvents_interestShortfall x , maybe [] (schemaTypeToXML "writedown") $ floatAmountEvents_writedown x , maybe [] (schemaTypeToXML "impliedWritedown") $ floatAmountEvents_impliedWritedown x , maybe [] (schemaTypeToXML "floatingAmountProvisions") $ floatAmountEvents_floatingAmountProvisions x , maybe [] (schemaTypeToXML "additionalFixedPayments") $ floatAmountEvents_additionalFixedPayments x ] data FloatingAmountProvisions = FloatingAmountProvisions { floatAmountProvis_wACCapInterestProvision :: Maybe Xsd.Boolean -- ^ As specified by the ISDA Supplement for use with trades on -- mortgage-backed securities, "WAC Cap" means a weighted -- average coupon or weighted average rate cap provision -- (however defined in the Underlying Instruments) of the -- Underlying Instruments that limits, increases or decreases -- the interest rate or interest entitlement, as set out in -- the Underlying Instruments on the Effective Date without -- regard to any subsequent amendment The presence of the -- element with value set to 'true' signifies that the -- provision is applicable. From a usage standpoint, this -- provision is typically applicable in the case of CMBS and -- not applicable in case of RMBS trades. , floatAmountProvis_stepUpProvision :: Maybe Xsd.Boolean -- ^ As specified by the ISDA Standard Terms Supplement for use -- with trades on mortgage-backed securities. The presence of -- the element with value set to 'true' signifies that the -- provision is applicable. If applicable, the applicable -- step-up terms are specified as part of that ISDA Standard -- Terms Supplement. From a usage standpoint, this provision -- is typically applicable in the case of RMBS and not -- applicable in case of CMBS trades. } deriving (Eq,Show) instance SchemaType FloatingAmountProvisions where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return FloatingAmountProvisions `apply` optional (parseSchemaType "WACCapInterestProvision") `apply` optional (parseSchemaType "stepUpProvision") schemaTypeToXML s x@FloatingAmountProvisions{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "WACCapInterestProvision") $ floatAmountProvis_wACCapInterestProvision x , maybe [] (schemaTypeToXML "stepUpProvision") $ floatAmountProvis_stepUpProvision x ] data GeneralTerms = GeneralTerms { generalTerms_effectiveDate :: AdjustableDate2 -- ^ The first day of the term of the trade. This day may be -- subject to adjustment in accordance with a business day -- convention. ISDA 2003 Term: Effective Date. , generalTerms_scheduledTerminationDate :: AdjustableDate2 -- ^ The scheduled date on which the credit protection will -- lapse. This day may be subject to adjustment in accordance -- with a business day convention. ISDA 2003 Term: Scheduled -- Termination Date. , generalTerms_buyerPartyReference :: Maybe PartyReference -- ^ A reference to the party that buys this instrument, ie. -- pays for this instrument and receives the rights defined by -- it. See 2000 ISDA definitions Article 11.1 (b). In the case -- of FRAs this the fixed rate payer. , generalTerms_buyerAccountReference :: Maybe AccountReference -- ^ A reference to the account that buys this instrument. , generalTerms_sellerPartyReference :: Maybe PartyReference -- ^ A reference to the party that sells ("writes") this -- instrument, i.e. that grants the rights defined by this -- instrument and in return receives a payment for it. See -- 2000 ISDA definitions Article 11.1 (a). In the case of FRAs -- this is the floating rate payer. , generalTerms_sellerAccountReference :: Maybe AccountReference -- ^ A reference to the account that sells this instrument. , generalTerms_dateAdjustments :: Maybe BusinessDayAdjustments -- ^ ISDA 2003 Terms: Business Day and Business Day Convention. , generalTerms_choice7 :: OneOf3 ReferenceInformation IndexReferenceInformation BasketReferenceInformation -- ^ Choice between: -- -- (1) This element contains all the terms relevant to -- defining the reference entity and reference -- obligation(s). -- -- (2) This element contains all the terms relevant to -- defining the Credit DefaultSwap Index. -- -- (3) This element contains all the terms relevant to -- defining the Credit Default Swap Basket. , generalTerms_additionalTerm :: [AdditionalTerm] -- ^ This element is used for representing information contained -- in the Additional Terms field of the 2003 Master Credit -- Derivatives confirm. , generalTerms_substitution :: Maybe Xsd.Boolean -- ^ Value of this element set to 'true' indicates that -- substitution is applicable. , generalTerms_modifiedEquityDelivery :: Maybe Xsd.Boolean -- ^ Value of this element set to 'true' indicates that modified -- equity delivery is applicable. } deriving (Eq,Show) instance SchemaType GeneralTerms where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return GeneralTerms `apply` parseSchemaType "effectiveDate" `apply` parseSchemaType "scheduledTerminationDate" `apply` optional (parseSchemaType "buyerPartyReference") `apply` optional (parseSchemaType "buyerAccountReference") `apply` optional (parseSchemaType "sellerPartyReference") `apply` optional (parseSchemaType "sellerAccountReference") `apply` optional (parseSchemaType "dateAdjustments") `apply` oneOf' [ ("ReferenceInformation", fmap OneOf3 (parseSchemaType "referenceInformation")) , ("IndexReferenceInformation", fmap TwoOf3 (parseSchemaType "indexReferenceInformation")) , ("BasketReferenceInformation", fmap ThreeOf3 (parseSchemaType "basketReferenceInformation")) ] `apply` many (parseSchemaType "additionalTerm") `apply` optional (parseSchemaType "substitution") `apply` optional (parseSchemaType "modifiedEquityDelivery") schemaTypeToXML s x@GeneralTerms{} = toXMLElement s [] [ schemaTypeToXML "effectiveDate" $ generalTerms_effectiveDate x , schemaTypeToXML "scheduledTerminationDate" $ generalTerms_scheduledTerminationDate x , maybe [] (schemaTypeToXML "buyerPartyReference") $ generalTerms_buyerPartyReference x , maybe [] (schemaTypeToXML "buyerAccountReference") $ generalTerms_buyerAccountReference x , maybe [] (schemaTypeToXML "sellerPartyReference") $ generalTerms_sellerPartyReference x , maybe [] (schemaTypeToXML "sellerAccountReference") $ generalTerms_sellerAccountReference x , maybe [] (schemaTypeToXML "dateAdjustments") $ generalTerms_dateAdjustments x , foldOneOf3 (schemaTypeToXML "referenceInformation") (schemaTypeToXML "indexReferenceInformation") (schemaTypeToXML "basketReferenceInformation") $ generalTerms_choice7 x , concatMap (schemaTypeToXML "additionalTerm") $ generalTerms_additionalTerm x , maybe [] (schemaTypeToXML "substitution") $ generalTerms_substitution x , maybe [] (schemaTypeToXML "modifiedEquityDelivery") $ generalTerms_modifiedEquityDelivery x ] data IndexAnnexSource = IndexAnnexSource Scheme IndexAnnexSourceAttributes deriving (Eq,Show) data IndexAnnexSourceAttributes = IndexAnnexSourceAttributes { indexAnnexSourceAttrib_indexAnnexSourceScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType IndexAnnexSource where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "indexAnnexSourceScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ IndexAnnexSource v (IndexAnnexSourceAttributes a0) schemaTypeToXML s (IndexAnnexSource bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "indexAnnexSourceScheme") $ indexAnnexSourceAttrib_indexAnnexSourceScheme at ] $ schemaTypeToXML s bt instance Extension IndexAnnexSource Scheme where supertype (IndexAnnexSource s _) = s data IndexId = IndexId Scheme IndexIdAttributes deriving (Eq,Show) data IndexIdAttributes = IndexIdAttributes { indexIdAttrib_indexIdScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType IndexId where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "indexIdScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ IndexId v (IndexIdAttributes a0) schemaTypeToXML s (IndexId bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "indexIdScheme") $ indexIdAttrib_indexIdScheme at ] $ schemaTypeToXML s bt instance Extension IndexId Scheme where supertype (IndexId s _) = s data IndexName = IndexName Scheme IndexNameAttributes deriving (Eq,Show) data IndexNameAttributes = IndexNameAttributes { indexNameAttrib_indexNameScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType IndexName where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "indexNameScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ IndexName v (IndexNameAttributes a0) schemaTypeToXML s (IndexName bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "indexNameScheme") $ indexNameAttrib_indexNameScheme at ] $ schemaTypeToXML s bt instance Extension IndexName Scheme where supertype (IndexName s _) = s -- | A type defining a Credit Default Swap Index. data IndexReferenceInformation = IndexReferenceInformation { indexRefInfo_ID :: Maybe Xsd.ID , indexRefInfo_choice0 :: OneOf2 (IndexName,[IndexId]) [IndexId] -- ^ Choice between: -- -- (1) Sequence of: -- -- * The name of the index expressed as a free format -- string. FpML does not define usage rules for this -- element. -- -- * A CDS index identifier (e.g. RED pair code). -- -- (2) A CDS index identifier (e.g. RED pair code). , indexRefInfo_indexSeries :: Maybe Xsd.PositiveInteger -- ^ A CDS index series identifier, e.g. 1, 2, 3 etc. , indexRefInfo_indexAnnexVersion :: Maybe Xsd.PositiveInteger -- ^ A CDS index series version identifier, e.g. 1, 2, 3 etc. , indexRefInfo_indexAnnexDate :: Maybe Xsd.Date -- ^ A CDS index series annex date. , indexRefInfo_indexAnnexSource :: Maybe IndexAnnexSource -- ^ A CDS index series annex source. , indexRefInfo_excludedReferenceEntity :: [LegalEntity] -- ^ Excluded reference entity. , indexRefInfo_tranche :: Maybe Tranche -- ^ This element contains CDS tranche terms. , indexRefInfo_settledEntityMatrix :: Maybe SettledEntityMatrix -- ^ Used to specify the Relevant Settled Entity Matrix when -- there are settled entities at the time of the trade. } deriving (Eq,Show) instance SchemaType IndexReferenceInformation where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (IndexReferenceInformation a0) `apply` oneOf' [ ("IndexName [IndexId]", fmap OneOf2 (return (,) `apply` parseSchemaType "indexName" `apply` many (parseSchemaType "indexId"))) , ("[IndexId]", fmap TwoOf2 (many1 (parseSchemaType "indexId"))) ] `apply` optional (parseSchemaType "indexSeries") `apply` optional (parseSchemaType "indexAnnexVersion") `apply` optional (parseSchemaType "indexAnnexDate") `apply` optional (parseSchemaType "indexAnnexSource") `apply` many (parseSchemaType "excludedReferenceEntity") `apply` optional (parseSchemaType "tranche") `apply` optional (parseSchemaType "settledEntityMatrix") schemaTypeToXML s x@IndexReferenceInformation{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ indexRefInfo_ID x ] [ foldOneOf2 (\ (a,b) -> concat [ schemaTypeToXML "indexName" a , concatMap (schemaTypeToXML "indexId") b ]) (concatMap (schemaTypeToXML "indexId")) $ indexRefInfo_choice0 x , maybe [] (schemaTypeToXML "indexSeries") $ indexRefInfo_indexSeries x , maybe [] (schemaTypeToXML "indexAnnexVersion") $ indexRefInfo_indexAnnexVersion x , maybe [] (schemaTypeToXML "indexAnnexDate") $ indexRefInfo_indexAnnexDate x , maybe [] (schemaTypeToXML "indexAnnexSource") $ indexRefInfo_indexAnnexSource x , concatMap (schemaTypeToXML "excludedReferenceEntity") $ indexRefInfo_excludedReferenceEntity x , maybe [] (schemaTypeToXML "tranche") $ indexRefInfo_tranche x , maybe [] (schemaTypeToXML "settledEntityMatrix") $ indexRefInfo_settledEntityMatrix x ] data InitialPayment = InitialPayment { initialPayment_ID :: Maybe Xsd.ID , initialPayment_payerPartyReference :: Maybe PartyReference -- ^ A reference to the party responsible for making the -- payments defined by this structure. , initialPayment_payerAccountReference :: Maybe AccountReference -- ^ A reference to the account responsible for making the -- payments defined by this structure. , initialPayment_receiverPartyReference :: Maybe PartyReference -- ^ A reference to the party that receives the payments -- corresponding to this structure. , initialPayment_receiverAccountReference :: Maybe AccountReference -- ^ A reference to the account that receives the payments -- corresponding to this structure. , initialPayment_adjustablePaymentDate :: Maybe Xsd.Date -- ^ A fixed payment date that shall be subject to adjustment in -- accordance with the applicable business day convention if -- it would otherwise fall on a day that is not a business -- day. The applicable business day convention and business -- day are those specified in the dateAdjustments element -- within the generalTerms component. , initialPayment_adjustedPaymentDate :: Maybe Xsd.Date -- ^ The adjusted payment date. This date should already be -- adjusted for any applicable business day convention. This -- component is not intended for use in trade confirmation but -- may be specified to allow the fee structure to also serve -- as a cashflow type component. , initialPayment_paymentAmount :: Money -- ^ A fixed payment amount. } deriving (Eq,Show) instance SchemaType InitialPayment where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (InitialPayment a0) `apply` optional (parseSchemaType "payerPartyReference") `apply` optional (parseSchemaType "payerAccountReference") `apply` optional (parseSchemaType "receiverPartyReference") `apply` optional (parseSchemaType "receiverAccountReference") `apply` optional (parseSchemaType "adjustablePaymentDate") `apply` optional (parseSchemaType "adjustedPaymentDate") `apply` parseSchemaType "paymentAmount" schemaTypeToXML s x@InitialPayment{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ initialPayment_ID x ] [ maybe [] (schemaTypeToXML "payerPartyReference") $ initialPayment_payerPartyReference x , maybe [] (schemaTypeToXML "payerAccountReference") $ initialPayment_payerAccountReference x , maybe [] (schemaTypeToXML "receiverPartyReference") $ initialPayment_receiverPartyReference x , maybe [] (schemaTypeToXML "receiverAccountReference") $ initialPayment_receiverAccountReference x , maybe [] (schemaTypeToXML "adjustablePaymentDate") $ initialPayment_adjustablePaymentDate x , maybe [] (schemaTypeToXML "adjustedPaymentDate") $ initialPayment_adjustedPaymentDate x , schemaTypeToXML "paymentAmount" $ initialPayment_paymentAmount x ] instance Extension InitialPayment PaymentBase where supertype v = PaymentBase_InitialPayment v data InterestShortFall = InterestShortFall { interShortFall_interestShortfallCap :: Maybe InterestShortfallCapEnum -- ^ Specifies the nature of the interest Shortfall cap (i.e. -- Fixed Cap or Variable Cap) in the case where it is -- applicable. ISDA 2003 Term: Interest Shortfall Cap. , interShortFall_compounding :: Maybe Xsd.Boolean , interShortFall_rateSource :: Maybe FloatingRateIndex -- ^ The rate source in the case of a variable cap. } deriving (Eq,Show) instance SchemaType InterestShortFall where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return InterestShortFall `apply` optional (parseSchemaType "interestShortfallCap") `apply` optional (parseSchemaType "compounding") `apply` optional (parseSchemaType "rateSource") schemaTypeToXML s x@InterestShortFall{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "interestShortfallCap") $ interShortFall_interestShortfallCap x , maybe [] (schemaTypeToXML "compounding") $ interShortFall_compounding x , maybe [] (schemaTypeToXML "rateSource") $ interShortFall_rateSource x ] data LoanParticipation = LoanParticipation { loanPartic_applicable :: Maybe Xsd.Boolean -- ^ Indicates whether the provision is applicable. , loanPartic_partialCashSettlement :: Maybe Xsd.Boolean -- ^ Specifies whether either 'Partial Cash Settlement of -- Assignable Loans', 'Partial Cash Settlement of Consent -- Required Loans' or 'Partial Cash Settlement of -- Participations' is applicable. If this element is specified -- and Assignable Loan is a Deliverable Obligation -- Chracteristic, any Assignable Loan that is deliverable, but -- where a non-receipt of Consent by the Physical Settlement -- Date has occurred, the Loan can be cash settled rather than -- physically delivered. If this element is specified and -- Consent Required Loan is a Deliverable Obligation -- Characterisitc, any Consent Required Loan that is -- deliverable, but where a non-receipt of Consent by the -- Physical Settlement Date has occurred, the Loan can be cash -- settled rather than physically delivered. If this element -- is specified and Direct Loan Participation is a Deliverable -- Obligation Characterisitic, any Participation that is -- deliverable, but where this participation has not been -- effected (has not come into effect) by the Physical -- Settlement Date, the participation can be cash settled -- rather than physically delivered. , loanPartic_qualifyingParticipationSeller :: Maybe Xsd.XsdString -- ^ If Direct Loan Participation is specified as a deliverable -- obligation characteristic, this specifies any requirements -- for the Qualifying Participation Seller. The requirements -- may be listed free-form. ISDA 2003 Term: Qualifying -- Participation Seller } deriving (Eq,Show) instance SchemaType LoanParticipation where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return LoanParticipation `apply` optional (parseSchemaType "applicable") `apply` optional (parseSchemaType "partialCashSettlement") `apply` optional (parseSchemaType "qualifyingParticipationSeller") schemaTypeToXML s x@LoanParticipation{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "applicable") $ loanPartic_applicable x , maybe [] (schemaTypeToXML "partialCashSettlement") $ loanPartic_partialCashSettlement x , maybe [] (schemaTypeToXML "qualifyingParticipationSeller") $ loanPartic_qualifyingParticipationSeller x ] instance Extension LoanParticipation PCDeliverableObligationCharac where supertype (LoanParticipation e0 e1 e2) = PCDeliverableObligationCharac e0 e1 data MatrixSource = MatrixSource Scheme MatrixSourceAttributes deriving (Eq,Show) data MatrixSourceAttributes = MatrixSourceAttributes { matrixSourceAttrib_settledEntityMatrixSourceScheme :: Maybe Xsd.AnyURI } deriving (Eq,Show) instance SchemaType MatrixSource where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ do a0 <- optional $ getAttribute "settledEntityMatrixSourceScheme" e pos reparse [CElem e pos] v <- parseSchemaType s return $ MatrixSource v (MatrixSourceAttributes a0) schemaTypeToXML s (MatrixSource bt at) = addXMLAttributes [ maybe [] (toXMLAttribute "settledEntityMatrixSourceScheme") $ matrixSourceAttrib_settledEntityMatrixSourceScheme at ] $ schemaTypeToXML s bt instance Extension MatrixSource Scheme where supertype (MatrixSource s _) = s data MultipleValuationDates = MultipleValuationDates { multiValDates_businessDays :: Maybe Xsd.NonNegativeInteger -- ^ A number of business days. Its precise meaning is dependant -- on the context in which this element is used. ISDA 2003 -- Term: Business Day , multiValDates_businessDaysThereafter :: Maybe Xsd.PositiveInteger -- ^ The number of business days between successive valuation -- dates when multiple valuation dates are applicable for cash -- settlement. ISDA 2003 Term: Business Days thereafter , multiValDates_numberValuationDates :: Maybe Xsd.PositiveInteger -- ^ Where multiple valuation dates are specified as being -- applicable for cash settlement, this element specifies (a) -- the number of applicable valuation dates, and (b) the -- number of business days after satisfaction of all -- conditions to settlement when the first such valuation date -- occurs, and (c) the number of business days thereafter of -- each successive valuation date. ISDA 2003 Term: Multiple -- Valuation Dates } deriving (Eq,Show) instance SchemaType MultipleValuationDates where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return MultipleValuationDates `apply` optional (parseSchemaType "businessDays") `apply` optional (parseSchemaType "businessDaysThereafter") `apply` optional (parseSchemaType "numberValuationDates") schemaTypeToXML s x@MultipleValuationDates{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "businessDays") $ multiValDates_businessDays x , maybe [] (schemaTypeToXML "businessDaysThereafter") $ multiValDates_businessDaysThereafter x , maybe [] (schemaTypeToXML "numberValuationDates") $ multiValDates_numberValuationDates x ] instance Extension MultipleValuationDates SingleValuationDate where supertype (MultipleValuationDates e0 e1 e2) = SingleValuationDate e0 data NotDomesticCurrency = NotDomesticCurrency { notDomestCurren_applicable :: Maybe Xsd.Boolean -- ^ Indicates whether the not domestic currency provision is -- applicable. , notDomestCurren_currency :: Maybe Currency -- ^ An explicit specification of the domestic currency. } deriving (Eq,Show) instance SchemaType NotDomesticCurrency where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return NotDomesticCurrency `apply` optional (parseSchemaType "applicable") `apply` optional (parseSchemaType "currency") schemaTypeToXML s x@NotDomesticCurrency{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "applicable") $ notDomestCurren_applicable x , maybe [] (schemaTypeToXML "currency") $ notDomestCurren_currency x ] data Obligations = Obligations { obligations_category :: Maybe ObligationCategoryEnum -- ^ Used in both obligations and deliverable obligations to -- represent a class or type of securities which apply. ISDA -- 2003 Term: Obligation Category/Deliverable Obligation -- Category , obligations_notSubordinated :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. An -- obligation that ranks at least equal with the most senior -- Reference Obligation in priority of payment or, if no -- Reference Obligation is specified in the related -- Confirmation, the obligations of the Reference Entity that -- are senior. ISDA 2003 Term: Not Subordinated , obligations_specifiedCurrency :: Maybe SpecifiedCurrency -- ^ An obligation and deliverable obligation characteristic. -- The currency or currencies in which an obligation or -- deliverable obligation must be payable. ISDA 2003 Term: -- Specified Currency , obligations_notSovereignLender :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Any obligation that is not primarily (majority) owed to a -- Sovereign or Supranational Organization. ISDA 2003 Term: -- Not Sovereign Lender , obligations_notDomesticCurrency :: Maybe NotDomesticCurrency -- ^ An obligation and deliverable obligation characteristic. -- Any obligation that is payable in any currency other than -- the domestic currency. Domestic currency is either the -- currency so specified or, if no currency is specified, the -- currency of (a) the reference entity, if the reference -- entity is a sovereign, or (b) the jurisdiction in which the -- relevant reference entity is organised, if the reference -- entity is not a sovereign. ISDA 2003 Term: Not Domestic -- Currency , obligations_notDomesticLaw :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. If -- the reference entity is a Sovereign, this means any -- obligation that is not subject to the laws of the reference -- entity. If the reference entity is not a sovereign, this -- means any obligation that is not subject to the laws of the -- jurisdiction of the reference entity. ISDA 2003 Term: Not -- Domestic Law , obligations_listed :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Indicates whether or not the obligation is quoted, listed -- or ordinarily purchased and sold on an exchange. ISDA 2003 -- Term: Listed , obligations_notDomesticIssuance :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Any obligation other than an obligation that was intended -- to be offered for sale primarily in the domestic market of -- the relevant Reference Entity. This specifies that the -- obligation must be an internationally recognized bond. ISDA -- 2003 Term: Not Domestic Issuance , obligations_choice8 :: (Maybe (OneOf3 Xsd.Boolean Xsd.Boolean Xsd.Boolean)) -- ^ Choice between: -- -- (1) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: Full Faith and Credit -- Obligation Liability -- -- (2) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: General Fund Obligation -- Liability -- -- (3) An obligation and deliverable obligation -- characteristic. Defined in the ISDA published -- additional provisions for U.S. Municipal as Reference -- Entity. ISDA 2003 Term: Revenue Obligation Liability , obligations_notContingent :: Maybe Xsd.Boolean -- ^ NOTE: Only allowed as an obligation charcteristic under -- ISDA Credit 1999. In essence Not Contingent means the -- repayment of principal cannot be dependant on a -- formula/index, i.e. to prevent the risk of being delivered -- an instrument that may never pay any element of principal, -- and to ensure that the obligation is interest bearing (on a -- regular schedule). ISDA 2003 Term: Not Contingent , obligations_excluded :: Maybe Xsd.XsdString -- ^ A free format string to specify any excluded obligations or -- deliverable obligations, as the case may be, of the -- reference entity or excluded types of obligations or -- deliverable obligations. ISDA 2003 Term: Excluded -- Obligations/Excluded Deliverable Obligations , obligations_othReferenceEntityObligations :: Maybe Xsd.XsdString -- ^ This element is used to specify any other obligations of a -- reference entity in both obligations and deliverable -- obligations. The obligations can be specified free-form. -- ISDA 2003 Term: Other Obligations of a Reference Entity , obligations_designatedPriority :: Maybe Lien -- ^ Applies to Loan CDS, to indicate what lien level is -- appropriate for a deliverable obligation. Applies to -- European Loan CDS, to indicate the Ranking of the -- obligation. Example: a 2nd lien Loan CDS would imply that -- the deliverable obligations are 1st or 2nd lien loans. , obligations_cashSettlementOnly :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Defined in the ISDA published Standard Terms Supplement for -- use with CDS Transactions on Leveraged Loans. ISDA 2003 -- Term: Cash Settlement Only. , obligations_deliveryOfCommitments :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Defined in the ISDA published Standard Terms Supplement for -- use with CDS Transactions on Leveraged Loans. ISDA 2003 -- Term: Delivery of Commitments. , obligations_continuity :: Maybe Xsd.Boolean -- ^ An obligation and deliverable obligation characteristic. -- Defined in the ISDA published Standard Terms Supplement for -- use with CDS Transactions on Leveraged Loans. ISDA 2003 -- Term: Continuity. } deriving (Eq,Show) instance SchemaType Obligations where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return Obligations `apply` optional (parseSchemaType "category") `apply` optional (parseSchemaType "notSubordinated") `apply` optional (parseSchemaType "specifiedCurrency") `apply` optional (parseSchemaType "notSovereignLender") `apply` optional (parseSchemaType "notDomesticCurrency") `apply` optional (parseSchemaType "notDomesticLaw") `apply` optional (parseSchemaType "listed") `apply` optional (parseSchemaType "notDomesticIssuance") `apply` optional (oneOf' [ ("Xsd.Boolean", fmap OneOf3 (parseSchemaType "fullFaithAndCreditObLiability")) , ("Xsd.Boolean", fmap TwoOf3 (parseSchemaType "generalFundObligationLiability")) , ("Xsd.Boolean", fmap ThreeOf3 (parseSchemaType "revenueObligationLiability")) ]) `apply` optional (parseSchemaType "notContingent") `apply` optional (parseSchemaType "excluded") `apply` optional (parseSchemaType "othReferenceEntityObligations") `apply` optional (parseSchemaType "designatedPriority") `apply` optional (parseSchemaType "cashSettlementOnly") `apply` optional (parseSchemaType "deliveryOfCommitments") `apply` optional (parseSchemaType "continuity") schemaTypeToXML s x@Obligations{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "category") $ obligations_category x , maybe [] (schemaTypeToXML "notSubordinated") $ obligations_notSubordinated x , maybe [] (schemaTypeToXML "specifiedCurrency") $ obligations_specifiedCurrency x , maybe [] (schemaTypeToXML "notSovereignLender") $ obligations_notSovereignLender x , maybe [] (schemaTypeToXML "notDomesticCurrency") $ obligations_notDomesticCurrency x , maybe [] (schemaTypeToXML "notDomesticLaw") $ obligations_notDomesticLaw x , maybe [] (schemaTypeToXML "listed") $ obligations_listed x , maybe [] (schemaTypeToXML "notDomesticIssuance") $ obligations_notDomesticIssuance x , maybe [] (foldOneOf3 (schemaTypeToXML "fullFaithAndCreditObLiability") (schemaTypeToXML "generalFundObligationLiability") (schemaTypeToXML "revenueObligationLiability") ) $ obligations_choice8 x , maybe [] (schemaTypeToXML "notContingent") $ obligations_notContingent x , maybe [] (schemaTypeToXML "excluded") $ obligations_excluded x , maybe [] (schemaTypeToXML "othReferenceEntityObligations") $ obligations_othReferenceEntityObligations x , maybe [] (schemaTypeToXML "designatedPriority") $ obligations_designatedPriority x , maybe [] (schemaTypeToXML "cashSettlementOnly") $ obligations_cashSettlementOnly x , maybe [] (schemaTypeToXML "deliveryOfCommitments") $ obligations_deliveryOfCommitments x , maybe [] (schemaTypeToXML "continuity") $ obligations_continuity x ] data PCDeliverableObligationCharac = PCDeliverableObligationCharac { pCDelivObligCharac_applicable :: Maybe Xsd.Boolean -- ^ Indicates whether the provision is applicable. , pCDelivObligCharac_partialCashSettlement :: Maybe Xsd.Boolean -- ^ Specifies whether either 'Partial Cash Settlement of -- Assignable Loans', 'Partial Cash Settlement of Consent -- Required Loans' or 'Partial Cash Settlement of -- Participations' is applicable. If this element is specified -- and Assignable Loan is a Deliverable Obligation -- Chracteristic, any Assignable Loan that is deliverable, but -- where a non-receipt of Consent by the Physical Settlement -- Date has occurred, the Loan can be cash settled rather than -- physically delivered. If this element is specified and -- Consent Required Loan is a Deliverable Obligation -- Characterisitc, any Consent Required Loan that is -- deliverable, but where a non-receipt of Consent by the -- Physical Settlement Date has occurred, the Loan can be cash -- settled rather than physically delivered. If this element -- is specified and Direct Loan Participation is a Deliverable -- Obligation Characterisitic, any Participation that is -- deliverable, but where this participation has not been -- effected (has not come into effect) by the Physical -- Settlement Date, the participation can be cash settled -- rather than physically delivered. } deriving (Eq,Show) instance SchemaType PCDeliverableObligationCharac where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return PCDeliverableObligationCharac `apply` optional (parseSchemaType "applicable") `apply` optional (parseSchemaType "partialCashSettlement") schemaTypeToXML s x@PCDeliverableObligationCharac{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "applicable") $ pCDelivObligCharac_applicable x , maybe [] (schemaTypeToXML "partialCashSettlement") $ pCDelivObligCharac_partialCashSettlement x ] data PeriodicPayment = PeriodicPayment { periodPayment_ID :: Maybe Xsd.ID , periodPayment_paymentFrequency :: Maybe Period -- ^ The time interval between regular fixed rate payer payment -- dates. , periodPayment_firstPeriodStartDate :: Maybe Xsd.Date -- ^ The start date of the initial calculation period if such -- date is not equal to the trade’s effective date. It must -- only be specified if it is not equal to the effective date. -- The applicable business day convention and business day are -- those specified in the dateAdjustments element within the -- generalTerms component (or in a transaction supplement FpML -- representation defined within the referenced general terms -- confirmation agreement). , periodPayment_firstPaymentDate :: Maybe Xsd.Date -- ^ The first unadjusted fixed rate payer payment date. The -- applicable business day convention and business day are -- those specified in the dateAdjustments element within the -- generalTerms component (or in a transaction supplement FpML -- representation defined within the referenced general terms -- confirmation agreement). ISDA 2003 Term: Fixed Rate Payer -- Payment Date , periodPayment_lastRegularPaymentDate :: Maybe Xsd.Date -- ^ The last regular unadjusted fixed rate payer payment date. -- The applicable business day convention and business day are -- those specified in the dateAdjustments element within the -- generalTerms component (or in a transaction supplement FpML -- representation defined within the referenced general terms -- confirmation agreement). This element should only be -- included if there is a final payment stub, i.e. where the -- last regular unadjusted fixed rate payer payment date is -- not equal to the scheduled termination date. ISDA 2003 -- Term: Fixed Rate Payer Payment Date , periodPayment_rollConvention :: Maybe RollConventionEnum -- ^ Used in conjunction with the effectiveDate, -- scheduledTerminationDate, firstPaymentDate, -- lastRegularPaymentDate and paymentFrequency to determine -- the regular fixed rate payer payment dates. , periodPayment_choice5 :: OneOf2 Money FixedAmountCalculation -- ^ Choice between: -- -- (1) A fixed payment amount. ISDA 2003 Term: Fixed Amount -- -- (2) This element contains all the terms relevant to -- calculating a fixed amount where the fixed amount is -- calculated by reference to a per annum fixed rate. -- There is no corresponding ISDA 2003 Term. The -- equivalent is Sec 5.1 "Calculation of Fixed Amount" but -- this in itself is not a defined Term. , periodPayment_adjustedPaymentDates :: [AdjustedPaymentDates] -- ^ An optional cashflow-like structure allowing the equivalent -- representation of the periodic fixed payments in terms of a -- series of adjusted payment dates and amounts. This is -- intended to support application integration within an -- organisation and is not intended for use in inter-firm -- communication or confirmations. ISDA 2003 Term: Fixed Rate -- Payer Payment Date } deriving (Eq,Show) instance SchemaType PeriodicPayment where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (PeriodicPayment a0) `apply` optional (parseSchemaType "paymentFrequency") `apply` optional (parseSchemaType "firstPeriodStartDate") `apply` optional (parseSchemaType "firstPaymentDate") `apply` optional (parseSchemaType "lastRegularPaymentDate") `apply` optional (parseSchemaType "rollConvention") `apply` oneOf' [ ("Money", fmap OneOf2 (parseSchemaType "fixedAmount")) , ("FixedAmountCalculation", fmap TwoOf2 (parseSchemaType "fixedAmountCalculation")) ] `apply` many (parseSchemaType "adjustedPaymentDates") schemaTypeToXML s x@PeriodicPayment{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ periodPayment_ID x ] [ maybe [] (schemaTypeToXML "paymentFrequency") $ periodPayment_paymentFrequency x , maybe [] (schemaTypeToXML "firstPeriodStartDate") $ periodPayment_firstPeriodStartDate x , maybe [] (schemaTypeToXML "firstPaymentDate") $ periodPayment_firstPaymentDate x , maybe [] (schemaTypeToXML "lastRegularPaymentDate") $ periodPayment_lastRegularPaymentDate x , maybe [] (schemaTypeToXML "rollConvention") $ periodPayment_rollConvention x , foldOneOf2 (schemaTypeToXML "fixedAmount") (schemaTypeToXML "fixedAmountCalculation") $ periodPayment_choice5 x , concatMap (schemaTypeToXML "adjustedPaymentDates") $ periodPayment_adjustedPaymentDates x ] instance Extension PeriodicPayment PaymentBase where supertype v = PaymentBase_PeriodicPayment v data PhysicalSettlementPeriod = PhysicalSettlementPeriod { physicSettlPeriod_choice0 :: (Maybe (OneOf3 Xsd.Boolean Xsd.NonNegativeInteger Xsd.NonNegativeInteger)) -- ^ Choice between: -- -- (1) An explicit indication that a number of business days -- are not specified and therefore ISDA fallback -- provisions should apply. -- -- (2) A number of business days. Its precise meaning is -- dependant on the context in which this element is used. -- ISDA 2003 Term: Business Day -- -- (3) A maximum number of business days. Its precise meaning -- is dependant on the context in which this element is -- used. Intended to be used to limit a particular ISDA -- fallback provision. } deriving (Eq,Show) instance SchemaType PhysicalSettlementPeriod where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return PhysicalSettlementPeriod `apply` optional (oneOf' [ ("Xsd.Boolean", fmap OneOf3 (parseSchemaType "businessDaysNotSpecified")) , ("Xsd.NonNegativeInteger", fmap TwoOf3 (parseSchemaType "businessDays")) , ("Xsd.NonNegativeInteger", fmap ThreeOf3 (parseSchemaType "maximumBusinessDays")) ]) schemaTypeToXML s x@PhysicalSettlementPeriod{} = toXMLElement s [] [ maybe [] (foldOneOf3 (schemaTypeToXML "businessDaysNotSpecified") (schemaTypeToXML "businessDays") (schemaTypeToXML "maximumBusinessDays") ) $ physicSettlPeriod_choice0 x ] data PhysicalSettlementTerms = PhysicalSettlementTerms { physicSettlTerms_ID :: Maybe Xsd.ID , physicSettlTerms_settlementCurrency :: Maybe Currency -- ^ ISDA 2003 Term: Settlement Currency , physicSettlTerms_physicalSettlementPeriod :: Maybe PhysicalSettlementPeriod -- ^ The number of business days used in the determination of -- the physical settlement date. The physical settlement date -- is this number of business days after all applicable -- conditions to settlement are satisfied. If a number of -- business days is not specified fallback provisions apply -- for determining the number of business days. If Section -- 8.5/8.6 of the 1999/2003 ISDA Definitions are to apply the -- businessDaysNotSpecified element should be included. If a -- specified number of business days are to apply these should -- be specified in the businessDays element. If Section -- 8.5/8.6 of the 1999/2003 ISDA Definitions are to apply but -- capped at a maximum number of business days then the -- maximum number should be specified in the -- maximumBusinessDays element. ISDA 2003 Term: Physical -- Settlement Period , physicSettlTerms_deliverableObligations :: Maybe DeliverableObligations -- ^ This element contains all the ISDA terms relevant to -- defining the deliverable obligations. , physicSettlTerms_escrow :: Maybe Xsd.Boolean -- ^ If this element is specified and set to 'true', indicates -- that physical settlement must take place through the use of -- an escrow agent. (For Canadian counterparties this is -- always "Not Applicable". ISDA 2003 Term: Escrow. , physicSettlTerms_sixtyBusinessDaySettlementCap :: Maybe Xsd.Boolean -- ^ If this element is specified and set to 'true', for a -- transaction documented under the 2003 ISDA Credit -- Derivatives Definitions, has the effect of incorporating -- the language set forth below into the confirmation. The -- section references are to the 2003 ISDA Credit Derivatives -- Definitions. Notwithstanding Section 1.7 or any provisions -- of Sections 9.9 or 9.10 to the contrary, but without -- prejudice to Section 9.3 and (where applicable) Sections -- 9.4, 9.5 and 9.6, if the Termination Date has not occurred -- on or prior to the date that is 60 Business Days following -- the Physical Settlement Date, such 60th Business Day shall -- be deemed to be the Termination Date with respect to this -- Transaction except in relation to any portion of the -- Transaction (an "Affected Portion") in respect of which: -- (1) a valid notice of Buy-in Price has been delivered that -- is effective fewer than three Business Days prior to such -- 60th Business Day, in which case the Termination Date for -- that Affected Portion shall be the third Business Day -- following the date on which such notice is effective; or -- (2) Buyer has purchased but not Delivered Deliverable -- Obligations validly specified by Seller pursuant to Section -- 9.10(b), in which case the Termination Date for that -- Affected Portion shall be the tenth Business Day following -- the date on which Seller validly specified such Deliverable -- Obligations to Buyer. } deriving (Eq,Show) instance SchemaType PhysicalSettlementTerms where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (PhysicalSettlementTerms a0) `apply` optional (parseSchemaType "settlementCurrency") `apply` optional (parseSchemaType "physicalSettlementPeriod") `apply` optional (parseSchemaType "deliverableObligations") `apply` optional (parseSchemaType "escrow") `apply` optional (parseSchemaType "sixtyBusinessDaySettlementCap") schemaTypeToXML s x@PhysicalSettlementTerms{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ physicSettlTerms_ID x ] [ maybe [] (schemaTypeToXML "settlementCurrency") $ physicSettlTerms_settlementCurrency x , maybe [] (schemaTypeToXML "physicalSettlementPeriod") $ physicSettlTerms_physicalSettlementPeriod x , maybe [] (schemaTypeToXML "deliverableObligations") $ physicSettlTerms_deliverableObligations x , maybe [] (schemaTypeToXML "escrow") $ physicSettlTerms_escrow x , maybe [] (schemaTypeToXML "sixtyBusinessDaySettlementCap") $ physicSettlTerms_sixtyBusinessDaySettlementCap x ] instance Extension PhysicalSettlementTerms SettlementTerms where supertype (PhysicalSettlementTerms a0 e0 e1 e2 e3 e4) = SettlementTerms a0 e0 data ProtectionTerms = ProtectionTerms { protecTerms_ID :: Maybe Xsd.ID , protecTerms_calculationAmount :: Money -- ^ The notional amount of protection coverage. ISDA 2003 Term: -- Floating Rate Payer Calculation Amount , protecTerms_creditEvents :: Maybe CreditEvents -- ^ This element contains all the ISDA terms relating to credit -- events. , protecTerms_obligations :: Maybe Obligations -- ^ The underlying obligations of the reference entity on which -- you are buying or selling protection. The credit events -- Failure to Pay, Obligation Acceleration, Obligation -- Default, Restructuring, Repudiation/Moratorium are defined -- with respect to these obligations. ISDA 2003 Term: , protecTerms_floatingAmountEvents :: Maybe FloatingAmountEvents -- ^ This element contains the ISDA terms relating to the -- floating rate payment events and the implied additional -- fixed payments, applicable to the credit derivatives -- transactions on mortgage-backed securities with -- pay-as-you-go or physical settlement. } deriving (Eq,Show) instance SchemaType ProtectionTerms where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (ProtectionTerms a0) `apply` parseSchemaType "calculationAmount" `apply` optional (parseSchemaType "creditEvents") `apply` optional (parseSchemaType "obligations") `apply` optional (parseSchemaType "floatingAmountEvents") schemaTypeToXML s x@ProtectionTerms{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ protecTerms_ID x ] [ schemaTypeToXML "calculationAmount" $ protecTerms_calculationAmount x , maybe [] (schemaTypeToXML "creditEvents") $ protecTerms_creditEvents x , maybe [] (schemaTypeToXML "obligations") $ protecTerms_obligations x , maybe [] (schemaTypeToXML "floatingAmountEvents") $ protecTerms_floatingAmountEvents x ] -- | Reference to protectionTerms component. data ProtectionTermsReference = ProtectionTermsReference { protecTermsRef_href :: Xsd.IDREF } deriving (Eq,Show) instance SchemaType ProtectionTermsReference where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- getAttribute "href" e pos commit $ interior e $ return (ProtectionTermsReference a0) schemaTypeToXML s x@ProtectionTermsReference{} = toXMLElement s [ toXMLAttribute "href" $ protecTermsRef_href x ] [] instance Extension ProtectionTermsReference Reference where supertype v = Reference_ProtectionTermsReference v data ReferenceInformation = ReferenceInformation { refInfo_referenceEntity :: LegalEntity -- ^ The corporate or sovereign entity on which you are buying -- or selling protection and any successor that assumes all or -- substantially all of its contractual and other obligations. -- It is vital to use the correct legal name of the entity and -- to be careful not to choose a subsidiary if you really want -- to trade protection on a parent company. Please note, -- Reference Entities cannot be senior or subordinated. It is -- the obligations of the Reference Entities that can be -- senior or subordinated. ISDA 2003 Term: Reference Entity , refInfo_choice1 :: (Maybe (OneOf3 [ReferenceObligation] Xsd.Boolean Xsd.Boolean)) -- ^ Choice between: -- -- (1) The Reference Obligation is a financial instrument that -- is either issued or guaranteed by the reference entity. -- It serves to clarify the precise reference entity -- protection is being offered upon, and its legal -- position with regard to other related firms -- (parents/subsidiaries). Furthermore the Reference -- Obligation is ALWAYS deliverable and establishes the -- Pari Passu ranking (as the deliverable bonds must rank -- equal to the reference obligation). ISDA 2003 Term: -- Reference Obligation -- -- (2) Used to indicate that there is no Reference Obligation -- associated with this Credit Default Swap and that there -- will never be one. -- -- (3) Used to indicate that the Reference obligation -- associated with the Credit Default Swap is currently -- not known. This is not valid for Legal Confirmation -- purposes, but is valid for earlier stages in the trade -- life cycle (e.g. Broker Confirmation). , refInfo_allGuarantees :: Maybe Xsd.Boolean -- ^ Indicates whether an obligation of the Reference Entity, -- guaranteed by the Reference Entity on behalf of a -- non-Affiliate, is to be considered an Obligation for the -- purpose of the transaction. It will be considered an -- obligation if allGuarantees is applicable (true) and not if -- allGuarantees is inapplicable (false). ISDA 2003 Term: All -- Guarantees , refInfo_referencePrice :: Maybe Xsd.Decimal -- ^ Used to determine (a) for physically settled trades, the -- Physical Settlement Amount, which equals the Floating Rate -- Payer Calculation Amount times the Reference Price and (b) -- for cash settled trades, the Cash Settlement Amount, which -- equals the greater of (i) the difference between the -- Reference Price and the Final Price and (ii) zero. ISDA -- 2003 Term: Reference Price , refInfo_referencePolicy :: Maybe Xsd.Boolean -- ^ Applicable to the transactions on mortgage-backed security, -- which can make use of a reference policy. Presence of the -- element with value set to 'true' indicates that the -- reference policy is applicable; absence implies that it is -- not. , refInfo_securedList :: Maybe Xsd.Boolean -- ^ With respect to any day, the list of Syndicated Secured -- Obligations of the Designated Priority of the Reference -- Entity published by Markit Group Limited or any successor -- thereto appointed by the Specified Dealers (the "Secured -- List Publisher") on or most recently before such day, which -- list is currently available at [http://www.markit.com]. -- ISDA 2003 Term: Relevant Secured List. } deriving (Eq,Show) instance SchemaType ReferenceInformation where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ReferenceInformation `apply` parseSchemaType "referenceEntity" `apply` optional (oneOf' [ ("[ReferenceObligation]", fmap OneOf3 (many1 (parseSchemaType "referenceObligation"))) , ("Xsd.Boolean", fmap TwoOf3 (parseSchemaType "noReferenceObligation")) , ("Xsd.Boolean", fmap ThreeOf3 (parseSchemaType "unknownReferenceObligation")) ]) `apply` optional (parseSchemaType "allGuarantees") `apply` optional (parseSchemaType "referencePrice") `apply` optional (parseSchemaType "referencePolicy") `apply` optional (parseSchemaType "securedList") schemaTypeToXML s x@ReferenceInformation{} = toXMLElement s [] [ schemaTypeToXML "referenceEntity" $ refInfo_referenceEntity x , maybe [] (foldOneOf3 (concatMap (schemaTypeToXML "referenceObligation")) (schemaTypeToXML "noReferenceObligation") (schemaTypeToXML "unknownReferenceObligation") ) $ refInfo_choice1 x , maybe [] (schemaTypeToXML "allGuarantees") $ refInfo_allGuarantees x , maybe [] (schemaTypeToXML "referencePrice") $ refInfo_referencePrice x , maybe [] (schemaTypeToXML "referencePolicy") $ refInfo_referencePolicy x , maybe [] (schemaTypeToXML "securedList") $ refInfo_securedList x ] data ReferenceObligation = ReferenceObligation { refOblig_choice0 :: (Maybe (OneOf4 Bond ConvertibleBond Mortgage Loan)) -- ^ Choice between: -- -- (1) Identifies the underlying asset when it is a series or -- a class of bonds. -- -- (2) Identifies the underlying asset when it is a -- convertible bond. -- -- (3) Identifies a mortgage backed security. -- -- (4) Identifies a simple underlying asset that is a loan. , refOblig_choice1 :: (Maybe (OneOf2 LegalEntity LegalEntityReference)) -- ^ Choice between: -- -- (1) The entity primarily responsible for repaying debt to a -- creditor as a result of borrowing or issuing bonds. -- ISDA 2003 Term: Primary Obligor -- -- (2) A pointer style reference to a reference entity defined -- elsewhere in the document. Used when the reference -- entity is the primary obligor. , refOblig_choice2 :: [OneOf2 LegalEntity LegalEntityReference] -- ^ Choice between: -- -- (1) The party that guarantees by way of a contractual -- arrangement to pay the debts of an obligor if the -- obligor is unable to make the required payments itself. -- ISDA 2003 Term: Guarantor -- -- (2) A pointer style reference to a reference entity defined -- elsewhere in the document. Used when the reference -- entity is the guarantor. } deriving (Eq,Show) instance SchemaType ReferenceObligation where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ReferenceObligation `apply` optional (oneOf' [ ("Bond", fmap OneOf4 (elementBond)) , ("ConvertibleBond", fmap TwoOf4 (elementConvertibleBond)) , ("Mortgage", fmap ThreeOf4 (elementMortgage)) , ("Loan", fmap FourOf4 (elementLoan)) ]) `apply` optional (oneOf' [ ("LegalEntity", fmap OneOf2 (parseSchemaType "primaryObligor")) , ("LegalEntityReference", fmap TwoOf2 (parseSchemaType "primaryObligorReference")) ]) `apply` many (oneOf' [ ("LegalEntity", fmap OneOf2 (parseSchemaType "guarantor")) , ("LegalEntityReference", fmap TwoOf2 (parseSchemaType "guarantorReference")) ]) schemaTypeToXML s x@ReferenceObligation{} = toXMLElement s [] [ maybe [] (foldOneOf4 (elementToXMLBond) (elementToXMLConvertibleBond) (elementToXMLMortgage) (elementToXMLLoan) ) $ refOblig_choice0 x , maybe [] (foldOneOf2 (schemaTypeToXML "primaryObligor") (schemaTypeToXML "primaryObligorReference") ) $ refOblig_choice1 x , concatMap (foldOneOf2 (schemaTypeToXML "guarantor") (schemaTypeToXML "guarantorReference") ) $ refOblig_choice2 x ] data ReferencePair = ReferencePair { refPair_referenceEntity :: Maybe LegalEntity -- ^ The corporate or sovereign entity on which you are buying -- or selling protection and any successor that assumes all or -- substantially all of its contractual and other obligations. -- It is vital to use the correct legal name of the entity and -- to be careful not to choose a subsidiary if you really want -- to trade protection on a parent company. Please note, -- Reference Entities cannot be senior or subordinated. It is -- the obligations of the Reference Entities that can be -- senior or subordinated. ISDA 2003 Term: Reference Entity , refPair_choice1 :: (Maybe (OneOf2 ReferenceObligation Xsd.Boolean)) -- ^ Choice between: -- -- (1) The Reference Obligation is a financial instrument that -- is either issued or guaranteed by the reference entity. -- It serves to clarify the precise reference entity -- protection is being offered upon, and its legal -- position with regard to other related firms -- (parents/subsidiaries). Furthermore the Reference -- Obligation is ALWAYS deliverable and establishes the -- Pari Passu ranking (as the deliverable bonds must rank -- equal to the reference obligation). ISDA 2003 Term: -- Reference Obligation -- -- (2) Used to indicate that there is no Reference Obligation -- associated with this Credit Default Swap and that there -- will never be one. , refPair_entityType :: Maybe EntityType -- ^ Defines the reference entity types corresponding to a list -- of types in the ISDA First to Default documentation. } deriving (Eq,Show) instance SchemaType ReferencePair where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ReferencePair `apply` optional (parseSchemaType "referenceEntity") `apply` optional (oneOf' [ ("ReferenceObligation", fmap OneOf2 (parseSchemaType "referenceObligation")) , ("Xsd.Boolean", fmap TwoOf2 (parseSchemaType "noReferenceObligation")) ]) `apply` optional (parseSchemaType "entityType") schemaTypeToXML s x@ReferencePair{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "referenceEntity") $ refPair_referenceEntity x , maybe [] (foldOneOf2 (schemaTypeToXML "referenceObligation") (schemaTypeToXML "noReferenceObligation") ) $ refPair_choice1 x , maybe [] (schemaTypeToXML "entityType") $ refPair_entityType x ] -- | This type contains all the reference pool items to define -- the reference entity and reference obligation(s) in the -- basket. data ReferencePool = ReferencePool { referencePool_item :: [ReferencePoolItem] } deriving (Eq,Show) instance SchemaType ReferencePool where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ReferencePool `apply` many (parseSchemaType "referencePoolItem") schemaTypeToXML s x@ReferencePool{} = toXMLElement s [] [ concatMap (schemaTypeToXML "referencePoolItem") $ referencePool_item x ] -- | This type contains all the constituent weight and reference -- information. data ReferencePoolItem = ReferencePoolItem { refPoolItem_constituentWeight :: Maybe ConstituentWeight -- ^ Describes the weight of each of the constituents within the -- basket. If not provided, it is assumed to be equal -- weighted. , refPoolItem_referencePair :: Maybe ReferencePair , refPoolItem_protectionTermsReference :: Maybe ProtectionTermsReference -- ^ Reference to the documentation terms applicable to this -- item. , refPoolItem_settlementTermsReference :: Maybe SettlementTermsReference -- ^ Reference to the settlement terms applicable to this item. } deriving (Eq,Show) instance SchemaType ReferencePoolItem where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ReferencePoolItem `apply` optional (parseSchemaType "constituentWeight") `apply` optional (parseSchemaType "referencePair") `apply` optional (parseSchemaType "protectionTermsReference") `apply` optional (parseSchemaType "settlementTermsReference") schemaTypeToXML s x@ReferencePoolItem{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "constituentWeight") $ refPoolItem_constituentWeight x , maybe [] (schemaTypeToXML "referencePair") $ refPoolItem_referencePair x , maybe [] (schemaTypeToXML "protectionTermsReference") $ refPoolItem_protectionTermsReference x , maybe [] (schemaTypeToXML "settlementTermsReference") $ refPoolItem_settlementTermsReference x ] data SettledEntityMatrix = SettledEntityMatrix { settledEntityMatrix_matrixSource :: Maybe MatrixSource -- ^ Relevant settled entity matrix source. , settledEntityMatrix_publicationDate :: Maybe Xsd.Date -- ^ Specifies the publication date of the applicable version of -- the matrix. When this element is omitted, the Standard -- Terms Supplement defines rules for which version of the -- matrix is applicable. } deriving (Eq,Show) instance SchemaType SettledEntityMatrix where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return SettledEntityMatrix `apply` optional (parseSchemaType "matrixSource") `apply` optional (parseSchemaType "publicationDate") schemaTypeToXML s x@SettledEntityMatrix{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "matrixSource") $ settledEntityMatrix_matrixSource x , maybe [] (schemaTypeToXML "publicationDate") $ settledEntityMatrix_publicationDate x ] data SettlementTerms = SettlementTerms { settlTerms_ID :: Maybe Xsd.ID , settlTerms_settlementCurrency :: Maybe Currency -- ^ ISDA 2003 Term: Settlement Currency } deriving (Eq,Show) instance SchemaType SettlementTerms where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (SettlementTerms a0) `apply` optional (parseSchemaType "settlementCurrency") schemaTypeToXML s x@SettlementTerms{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ settlTerms_ID x ] [ maybe [] (schemaTypeToXML "settlementCurrency") $ settlTerms_settlementCurrency x ] -- | Reference to a settlement terms derived construct -- (cashSettlementTerms or physicalSettlementTerms). data SettlementTermsReference = SettlementTermsReference { settlTermsRef_href :: Xsd.IDREF } deriving (Eq,Show) instance SchemaType SettlementTermsReference where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- getAttribute "href" e pos commit $ interior e $ return (SettlementTermsReference a0) schemaTypeToXML s x@SettlementTermsReference{} = toXMLElement s [ toXMLAttribute "href" $ settlTermsRef_href x ] [] instance Extension SettlementTermsReference Reference where supertype v = Reference_SettlementTermsReference v data SinglePayment = SinglePayment { singlePayment_ID :: Maybe Xsd.ID , singlePayment_adjustablePaymentDate :: Maybe Xsd.Date -- ^ A fixed amount payment date that shall be subject to -- adjustment in accordance with the applicable business day -- convention if it would otherwise fall on a day that is not -- a business day. The applicable business day convention and -- business day are those specified in the dateAdjustments -- element within the generalTerms component. ISDA 2003 Term: -- Fixed Rate Payer Payment Date , singlePayment_adjustedPaymentDate :: Maybe Xsd.Date -- ^ The adjusted payment date. This date should already be -- adjusted for any applicable business day convention. This -- component is not intended for use in trade confirmation but -- may be specified to allow the fee structure to also serve -- as a cashflow type component. , singlePayment_fixedAmount :: Money -- ^ A fixed payment amount. ISDA 2003 Term: Fixed Amount } deriving (Eq,Show) instance SchemaType SinglePayment where parseSchemaType s = do (pos,e) <- posnElement [s] a0 <- optional $ getAttribute "id" e pos commit $ interior e $ return (SinglePayment a0) `apply` optional (parseSchemaType "adjustablePaymentDate") `apply` optional (parseSchemaType "adjustedPaymentDate") `apply` parseSchemaType "fixedAmount" schemaTypeToXML s x@SinglePayment{} = toXMLElement s [ maybe [] (toXMLAttribute "id") $ singlePayment_ID x ] [ maybe [] (schemaTypeToXML "adjustablePaymentDate") $ singlePayment_adjustablePaymentDate x , maybe [] (schemaTypeToXML "adjustedPaymentDate") $ singlePayment_adjustedPaymentDate x , schemaTypeToXML "fixedAmount" $ singlePayment_fixedAmount x ] instance Extension SinglePayment PaymentBase where supertype v = PaymentBase_SinglePayment v data SingleValuationDate = SingleValuationDate { singleValDate_businessDays :: Maybe Xsd.NonNegativeInteger -- ^ A number of business days. Its precise meaning is dependant -- on the context in which this element is used. ISDA 2003 -- Term: Business Day } deriving (Eq,Show) instance SchemaType SingleValuationDate where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return SingleValuationDate `apply` optional (parseSchemaType "businessDays") schemaTypeToXML s x@SingleValuationDate{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "businessDays") $ singleValDate_businessDays x ] data SpecifiedCurrency = SpecifiedCurrency { specifCurren_applicable :: Maybe Xsd.Boolean -- ^ Indicates whether the specified currency provision is -- applicable. , specifCurren_currency :: [Currency] -- ^ The currency in which an amount is denominated. } deriving (Eq,Show) instance SchemaType SpecifiedCurrency where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return SpecifiedCurrency `apply` optional (parseSchemaType "applicable") `apply` many (parseSchemaType "currency") schemaTypeToXML s x@SpecifiedCurrency{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "applicable") $ specifCurren_applicable x , concatMap (schemaTypeToXML "currency") $ specifCurren_currency x ] -- | This type represents a CDS Tranche. data Tranche = Tranche { tranche_attachmentPoint :: Maybe Xsd.Decimal -- ^ Lower bound percentage of the loss that the Tranche can -- endure, expressed as a decimal. An attachment point of 5% -- would be represented as 0.05. The difference between -- Attachment and Exhaustion points is call the width of the -- Tranche. A schema facet to constraint the value between 0 -- to 1 will be introduced in FpML 4.3. , tranche_exhaustionPoint :: Maybe Xsd.Decimal -- ^ Upper bound percentage of the loss that the Tranche can -- endure, expressed as a decimal. An exhaustion point of 5% -- would be represented as 0.05. The difference between -- Attachment and Exhaustion points is call the width of the -- Tranche. A schema facet to constraint the value between 0 -- to 1 will be introduced in FpML 4.3. , tranche_incurredRecoveryApplicable :: Maybe Xsd.Boolean -- ^ Outstanding Swap Notional Amount is defined at any time on -- any day, as the greater of: (a) Zero; If Incurred Recovery -- Amount Applicable: (b) The Original Swap Notional Amount -- minus the sum of all Incurred Loss Amounts and all Incurred -- Recovery Amounts (if any) determined under this -- Confirmation at or prior to such time.Incurred Recovery -- Amount not populated: (b) The Original Swap Notional Amount -- minus the sum of all Incurred Loss Amounts determined under -- this Confirmation at or prior to such time. } deriving (Eq,Show) instance SchemaType Tranche where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return Tranche `apply` optional (parseSchemaType "attachmentPoint") `apply` optional (parseSchemaType "exhaustionPoint") `apply` optional (parseSchemaType "incurredRecoveryApplicable") schemaTypeToXML s x@Tranche{} = toXMLElement s [] [ maybe [] (schemaTypeToXML "attachmentPoint") $ tranche_attachmentPoint x , maybe [] (schemaTypeToXML "exhaustionPoint") $ tranche_exhaustionPoint x , maybe [] (schemaTypeToXML "incurredRecoveryApplicable") $ tranche_incurredRecoveryApplicable x ] data ValuationDate = ValuationDate { valDate_choice0 :: (Maybe (OneOf2 SingleValuationDate MultipleValuationDates)) -- ^ Choice between: -- -- (1) Where single valuation date is specified as being -- applicable for cash settlement, this element specifies -- the number of business days after satisfaction of all -- conditions to settlement when such valuation date -- occurs. ISDA 2003 Term: Single Valuation Date -- -- (2) Where multiple valuation dates are specified as being -- applicable for cash settlement, this element specifies -- (a) the number of applicable valuation dates, and (b) -- the number of business days after satisfaction of all -- conditions to settlement when the first such valuation -- date occurs, and (c) the number of business days -- thereafter of each successive valuation date. ISDA 2003 -- Term: Multiple Valuation Dates } deriving (Eq,Show) instance SchemaType ValuationDate where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return ValuationDate `apply` optional (oneOf' [ ("SingleValuationDate", fmap OneOf2 (parseSchemaType "singleValuationDate")) , ("MultipleValuationDates", fmap TwoOf2 (parseSchemaType "multipleValuationDates")) ]) schemaTypeToXML s x@ValuationDate{} = toXMLElement s [] [ maybe [] (foldOneOf2 (schemaTypeToXML "singleValuationDate") (schemaTypeToXML "multipleValuationDates") ) $ valDate_choice0 x ] -- | A limited version of the CDS type used as an underlyer to -- CDS options in Transparency view, to avoid requiring -- product type etc. data LimitedCreditDefaultSwap = LimitedCreditDefaultSwap { limitedCreditDefaultSwap_generalTerms :: GeneralTerms -- ^ This element contains all the data that appears in the -- section entitled "1. General Terms" in the 2003 ISDA Credit -- Derivatives Confirmation. , limitedCreditDefaultSwap_feeLeg :: FeeLeg -- ^ This element contains all the terms relevant to defining -- the fixed amounts/payments per the applicable ISDA -- definitions. , limitedCreditDefaultSwap_protectionTerms :: [ProtectionTerms] -- ^ This element contains all the terms relevant to defining -- the applicable floating rate payer calculation amount, -- credit events and associated conditions to settlement, and -- reference obligations. } deriving (Eq,Show) instance SchemaType LimitedCreditDefaultSwap where parseSchemaType s = do (pos,e) <- posnElement [s] commit $ interior e $ return LimitedCreditDefaultSwap `apply` parseSchemaType "generalTerms" `apply` parseSchemaType "feeLeg" `apply` many1 (parseSchemaType "protectionTerms") schemaTypeToXML s x@LimitedCreditDefaultSwap{} = toXMLElement s [] [ schemaTypeToXML "generalTerms" $ limitedCreditDefaultSwap_generalTerms x , schemaTypeToXML "feeLeg" $ limitedCreditDefaultSwap_feeLeg x , concatMap (schemaTypeToXML "protectionTerms") $ limitedCreditDefaultSwap_protectionTerms x ] -- | In a credit default swap one party (the protection seller) -- agrees to compensate another party (the protection buyer) -- if a specified company or Sovereign (the reference entity) -- experiences a credit event, indicating it is or may be -- unable to service its debts. The protection seller is -- typically paid a fee and/or premium, expressed as an -- annualized percent of the notional in basis points, -- regularly over the life of the transaction or otherwise as -- agreed by the parties. elementCreditDefaultSwap :: XMLParser CreditDefaultSwap elementCreditDefaultSwap = parseSchemaType "creditDefaultSwap" elementToXMLCreditDefaultSwap :: CreditDefaultSwap -> [Content ()] elementToXMLCreditDefaultSwap = schemaTypeToXML "creditDefaultSwap" -- | An option on a credit default swap. elementCreditDefaultSwapOption :: XMLParser CreditDefaultSwapOption elementCreditDefaultSwapOption = parseSchemaType "creditDefaultSwapOption" elementToXMLCreditDefaultSwapOption :: CreditDefaultSwapOption -> [Content ()] elementToXMLCreditDefaultSwapOption = schemaTypeToXML "creditDefaultSwapOption"