Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
// This file is auto-generated from the ISDA Common Domain Model, do not edit.
//
// Version: 5.0.1
//
[assembly: Rosetta.Lib.Attributes.CdmVersion("5.0.1")]
#nullable enable // Allow nullable reference types
namespace Org.Isda.Cdm
{
using System.Collections.Generic;
using Newtonsoft.Json;
using Newtonsoft.Json.Converters;
using NodaTime;
using Rosetta.Lib;
using Rosetta.Lib.Attributes;
using Rosetta.Lib.Meta;
using Rosetta.Lib.Validation;
using Org.Isda.Cdm.Meta;
using Org.Isda.Cdm.MetaFields;
using _MetaFields = Org.Isda.Cdm.MetaFields.MetaFields;
///
/// A class to specify an account as an account number alongside, optionally. an account name, an account type, an account beneficiary and a servicing party.
///
public class Account : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AccountMeta();
[JsonConstructor]
public Account(ReferenceWithMetaParty? partyReference, FieldWithMetaString accountNumber, FieldWithMetaString? accountName, FieldWithMetaAccountTypeEnum? accountType, ReferenceWithMetaParty? accountBeneficiary, ReferenceWithMetaParty? servicingParty, _MetaFields? meta)
{
PartyReference = partyReference;
AccountNumber = accountNumber;
AccountName = accountName;
AccountType = accountType;
AccountBeneficiary = accountBeneficiary;
ServicingParty = servicingParty;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A reference to the party to which the account refers to.
///
public ReferenceWithMetaParty? PartyReference { get; }
///
/// The account number.
///
public FieldWithMetaString AccountNumber { get; }
///
/// The name by which the account is known.
///
public FieldWithMetaString? AccountName { get; }
///
/// The type of account, e.g. client, house.
///
public FieldWithMetaAccountTypeEnum? AccountType { get; }
///
/// A reference to the party beneficiary of the account.
///
public ReferenceWithMetaParty? AccountBeneficiary { get; }
///
/// The reference to the legal entity that services the account, i.e. in the books of which the account is held.
///
public ReferenceWithMetaParty? ServicingParty { get; }
public _MetaFields? Meta { get; }
}
public class AcctOwnr : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AcctOwnrMeta();
[JsonConstructor]
public AcctOwnr(Id id)
{
Id = id;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
public Id Id { get; }
}
///
/// A type for defining the Additional Disruption Events.
///
public class AdditionalDisruptionEvents : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdditionalDisruptionEventsMeta();
[JsonConstructor]
public AdditionalDisruptionEvents(bool? changeInLaw, bool? failureToDeliver, bool? insolvencyFiling, bool? hedgingDisruption, bool? increasedCostOfHedging, bool? foreignOwnershipEvent, bool? lossOfStockBorrow, decimal? maximumStockLoanRate, bool? increasedCostOfStockBorrow, decimal? initialStockLoanRate, Enums.AncillaryRole? determiningParty, IEnumerable additionalBespokeTerms)
{
ChangeInLaw = changeInLaw;
FailureToDeliver = failureToDeliver;
InsolvencyFiling = insolvencyFiling;
HedgingDisruption = hedgingDisruption;
IncreasedCostOfHedging = increasedCostOfHedging;
ForeignOwnershipEvent = foreignOwnershipEvent;
LossOfStockBorrow = lossOfStockBorrow;
MaximumStockLoanRate = maximumStockLoanRate;
IncreasedCostOfStockBorrow = increasedCostOfStockBorrow;
InitialStockLoanRate = initialStockLoanRate;
DeterminingParty = determiningParty;
AdditionalBespokeTerms = additionalBespokeTerms;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Per 2002 ISDA Equity Derivatives Definitions:
///
public bool? ChangeInLaw { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions
///
public bool? FailureToDeliver { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions
///
public bool? InsolvencyFiling { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions
///
public bool? HedgingDisruption { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions
///
public bool? IncreasedCostOfHedging { get; }
///
/// Per ISDA Def
///
public bool? ForeignOwnershipEvent { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions:
///
public bool? LossOfStockBorrow { get; }
///
/// Specifies the maximum stock loan rate for Loss of Stock Borrow. A percentage of 5% is represented as 0.05.
///
public decimal? MaximumStockLoanRate { get; }
///
/// Per 2002 ISDA Equity Derivatives Definitions
///
public bool? IncreasedCostOfStockBorrow { get; }
///
/// Specifies the initial stock loan per ISDA Def. A percentage of 5% is represented as 0.05.
///
public decimal? InitialStockLoanRate { get; }
///
/// Specifies the party which determines additional disruption events.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AncillaryRole? DeterminingParty { get; }
///
/// Where parties may optionnaly describe any extra bespoke agreements, in regards of the standardized Extraordinary Events.
///
public IEnumerable AdditionalBespokeTerms { get; }
}
///
/// A class to specify the events that will give rise to the payment additional fixed payments.
///
public class AdditionalFixedPayments : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdditionalFixedPaymentsMeta();
[JsonConstructor]
public AdditionalFixedPayments(bool? interestShortfallReimbursement, bool? principalShortfallReimbursement, bool? writedownReimbursement)
{
InterestShortfallReimbursement = interestShortfallReimbursement;
PrincipalShortfallReimbursement = principalShortfallReimbursement;
WritedownReimbursement = writedownReimbursement;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// 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.
///
public bool? InterestShortfallReimbursement { get; }
///
/// 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.
///
public bool? PrincipalShortfallReimbursement { get; }
///
/// 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.
///
public bool? WritedownReimbursement { get; }
}
///
/// A class to specify a post or street address.
///
public class Address : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AddressMeta();
[JsonConstructor]
public Address(IEnumerable street, string? city, string? state, FieldWithMetaString? country, string? postalCode)
{
Street = street;
City = city;
State = state;
Country = country;
PostalCode = postalCode;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The set of street and building number information that identifies a postal address within a city.
///
public IEnumerable Street { get; }
///
/// The city component of the postal address.
///
public string? City { get; }
///
/// A country subdivision used in postal addresses in some countries. For example, US states, Canadian provinces, Swiss cantons, ...
///
public string? State { get; }
///
/// The ISO 3166 standard code for the country within which the postal address is located.
///
public FieldWithMetaString? Country { get; }
///
/// The code, required for computerized mail sorting systems, that is allocated to a physical address by a national postal authority.
///
public string? PostalCode { get; }
}
///
/// Specification of the address and other details for notices.
///
public class AddressForNotices : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AddressForNoticesMeta();
[JsonConstructor]
public AddressForNotices(ContactElection primaryNotices, IEnumerable additionalNotices)
{
PrimaryNotices = primaryNotices;
AdditionalNotices = additionalNotices;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specification of primary notice details
///
public ContactElection PrimaryNotices { get; }
///
/// The optional specification of additional information when a party requires notices to be delivered to more than one address.
///
public IEnumerable AdditionalNotices { get; }
}
public class AddtlAttrbts : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AddtlAttrbtsMeta();
[JsonConstructor]
public AddtlAttrbts(string rskRdcgTx, string sctiesFincgTxInd)
{
RskRdcgTx = rskRdcgTx;
SctiesFincgTxInd = sctiesFincgTxInd;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
public string RskRdcgTx { get; }
public string SctiesFincgTxInd { get; }
}
///
/// A class for defining a date that shall be subject to adjustment if it would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the date.
///
public class AdjustableDate : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableDateMeta();
[JsonConstructor]
public AdjustableDate(LocalDate? unadjustedDate, BusinessDayAdjustments? dateAdjustments, ReferenceWithMetaBusinessDayAdjustments? dateAdjustmentsReference, FieldWithMetaLocalDate? adjustedDate, _MetaFields? meta)
{
UnadjustedDate = unadjustedDate;
DateAdjustments = dateAdjustments;
DateAdjustmentsReference = dateAdjustmentsReference;
AdjustedDate = adjustedDate;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A date subject to adjustment. While in FpML this date is required, this cardinality constraint has been relaxed as part of the CDM in order to support the FRA representation, which effective and termination dates are specified in FpML as adjusted dates.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? UnadjustedDate { get; }
///
/// The business day convention and financial business centers used for adjusting the date if it would otherwise fall on a day that is not a business date in the specified business centers.
///
public BusinessDayAdjustments? DateAdjustments { get; }
///
/// A pointer style reference to date adjustments defined elsewhere in the document.
///
public ReferenceWithMetaBusinessDayAdjustments? DateAdjustmentsReference { get; }
///
/// The date once the adjustment has been performed. (Note that this date may change if the business center holidays change).
///
public FieldWithMetaLocalDate? AdjustedDate { get; }
public _MetaFields? Meta { get; }
}
///
/// A class for defining a series of dates that shall be subject to adjustment if they would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the dates.
///
public class AdjustableDates : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableDatesMeta();
[JsonConstructor]
public AdjustableDates(IEnumerable unadjustedDate, BusinessDayAdjustments? dateAdjustments, IEnumerable adjustedDate, _MetaFields? meta)
{
UnadjustedDate = unadjustedDate;
DateAdjustments = dateAdjustments;
AdjustedDate = adjustedDate;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A date subject to adjustment.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public IEnumerable UnadjustedDate { get; }
///
/// The business day convention and financial business centers used for adjusting the date if it would otherwise fall on a day that is not a business date in the specified business centers.
///
public BusinessDayAdjustments? DateAdjustments { get; }
///
/// The date(s) once the adjustment has been performed. (Note that this date may change if the business center holidays change).
///
public IEnumerable AdjustedDate { get; }
public _MetaFields? Meta { get; }
}
///
/// A class for defining a date that shall be subject to adjustment if it would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the date.
///
public class AdjustableOrAdjustedDate : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableOrAdjustedDateMeta();
[JsonConstructor]
public AdjustableOrAdjustedDate(LocalDate? unadjustedDate, BusinessDayAdjustments? dateAdjustments, FieldWithMetaLocalDate? adjustedDate, _MetaFields? meta)
{
UnadjustedDate = unadjustedDate;
DateAdjustments = dateAdjustments;
AdjustedDate = adjustedDate;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A date subject to adjustment.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? UnadjustedDate { get; }
///
/// The business day convention and financial business centers used for adjusting the date if it would otherwise fall on a day that is not a business date in the specified business centers.
///
public BusinessDayAdjustments? DateAdjustments { get; }
///
/// The date once the adjustment has been performed. (Note that this date may change if the business center holidays change).
///
public FieldWithMetaLocalDate? AdjustedDate { get; }
public _MetaFields? Meta { get; }
}
///
/// This Rosetta class specifies the date as either an unadjusted, adjusted or relative date. It supplements the features of the AdjustableOrAdjustedDate to support the credit default swap option premium, which uses the relative date construct.
///
public class AdjustableOrAdjustedOrRelativeDate : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableOrAdjustedOrRelativeDateMeta();
[JsonConstructor]
public AdjustableOrAdjustedOrRelativeDate(LocalDate? unadjustedDate, BusinessDayAdjustments? dateAdjustments, FieldWithMetaLocalDate? adjustedDate, RelativeDateOffset? relativeDate)
{
UnadjustedDate = unadjustedDate;
DateAdjustments = dateAdjustments;
AdjustedDate = adjustedDate;
RelativeDate = relativeDate;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A date subject to adjustment.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? UnadjustedDate { get; }
///
/// The business day convention and financial business centers used for adjusting the date if it would otherwise fall on a day that is not a business date in the specified business centers.
///
public BusinessDayAdjustments? DateAdjustments { get; }
///
/// The date once the adjustment has been performed. (Note that this date may change if the business center holidays change).
///
public FieldWithMetaLocalDate? AdjustedDate { get; }
///
/// A date specified as some offset to another date (the anchor date).
///
public RelativeDateOffset? RelativeDate { get; }
}
///
/// A class giving the choice between defining a date as an explicit date together with applicable adjustments or as relative to some other (anchor) date.
///
public class AdjustableOrRelativeDate : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableOrRelativeDateMeta();
[JsonConstructor]
public AdjustableOrRelativeDate(AdjustableDate? adjustableDate, AdjustedRelativeDateOffset? relativeDate, _MetaFields? meta)
{
AdjustableDate = adjustableDate;
RelativeDate = relativeDate;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A date that shall be subject to adjustment if it would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the date.
///
public AdjustableDate? AdjustableDate { get; }
///
/// A date specified as some offset to another date (the anchor date).
///
public AdjustedRelativeDateOffset? RelativeDate { get; }
public _MetaFields? Meta { get; }
}
///
/// A class giving the choice between defining a series of dates as an explicit list of dates together with applicable adjustments or as relative to some other series of (anchor) dates.
///
public class AdjustableOrRelativeDates : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableOrRelativeDatesMeta();
[JsonConstructor]
public AdjustableOrRelativeDates(AdjustableDates? adjustableDates, RelativeDates? relativeDates, _MetaFields? meta)
{
AdjustableDates = adjustableDates;
RelativeDates = relativeDates;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A series of dates that shall be subject to adjustment if they would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the date.
///
public AdjustableDates? AdjustableDates { get; }
///
/// A series of dates specified as some offset to another series of dates (the anchor dates).
///
public RelativeDates? RelativeDates { get; }
public _MetaFields? Meta { get; }
}
///
/// A class giving the choice between defining a series of dates as an explicit list of dates together with applicable adjustments or as relative to some other series of (anchor) dates, or as a calculation period schedule.
///
public class AdjustableRelativeOrPeriodicDates : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AdjustableRelativeOrPeriodicDatesMeta();
[JsonConstructor]
public AdjustableRelativeOrPeriodicDates(AdjustableDates? adjustableDates, RelativeDates? relativeDates, PeriodicDates? periodicDates, _MetaFields? meta)
{
AdjustableDates = adjustableDates;
RelativeDates = relativeDates;
PeriodicDates = periodicDates;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A series of dates that shall be subject to adjustment if they would otherwise fall on a day that is not a business day in the specified business centers, together with the convention for adjusting the date.
///
public AdjustableDates? AdjustableDates { get; }
///
/// A series of dates specified as some offset to another series of dates (the anchor dates).
///
public RelativeDates? RelativeDates { get; }
///
/// A calculation period schedule.
///
public PeriodicDates? PeriodicDates { get; }
public _MetaFields? Meta { get; }
}
///
/// A type defining a date (referred to as the derived date) as a relative offset from another date (referred to as the anchor date) plus optional date adjustments.
///
public class AdjustedRelativeDateOffset : AbstractRosettaModelObject, IRelativeDateOffset
{
private static readonly IRosettaMetaData metaData = new AdjustedRelativeDateOffsetMeta();
[JsonConstructor]
public AdjustedRelativeDateOffset(BusinessDayAdjustments? relativeDateAdjustments, Enums.BusinessDayConvention businessDayConvention, BusinessCenters? businessCenters, ReferenceWithMetaBusinessCenters? businessCentersReference, BasicReferenceWithMetaLocalDate? dateRelativeTo, LocalDate? adjustedDate, Enums.DayType? dayType, int periodMultiplier, Enums.Period period, _MetaFields? meta)
{
RelativeDateAdjustments = relativeDateAdjustments;
BusinessDayConvention = businessDayConvention;
BusinessCenters = businessCenters;
BusinessCentersReference = businessCentersReference;
DateRelativeTo = dateRelativeTo;
AdjustedDate = adjustedDate;
DayType = dayType;
PeriodMultiplier = periodMultiplier;
PeriodValue = period;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The business day convention and financial business centers used for adjusting the relative date if it would otherwise fall on a day that is not a business date in the specified business centers.
///
public BusinessDayAdjustments? RelativeDateAdjustments { get; }
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.BusinessDayConvention BusinessDayConvention { get; }
public BusinessCenters? BusinessCenters { get; }
///
public ReferenceWithMetaBusinessCenters? BusinessCentersReference { get; }
///
public BasicReferenceWithMetaLocalDate? DateRelativeTo { get; }
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? AdjustedDate { get; }
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.DayType? DayType { get; }
///
public int PeriodMultiplier { get; }
///
[JsonConverter(typeof(StringEnumConverter))]
[JsonProperty(PropertyName = "period")]
public Enums.Period PeriodValue { get; }
public _MetaFields? Meta { get; }
}
///
/// A class to specify a trade affirmation.
///
public class Affirmation : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AffirmationMeta();
[JsonConstructor]
public Affirmation(IEnumerable identifier, IEnumerable party, IEnumerable partyRole, Lineage? lineage, Enums.AffirmationStatus status)
{
Identifier = identifier;
Party = party;
PartyRole = partyRole;
Lineage = lineage;
Status = status;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The identifier(s) associated with the trade and resulting confirmation.
///
public IEnumerable Identifier { get; }
///
/// The parties associated with the trade.
///
public IEnumerable Party { get; }
///
/// The role(s) that party(ies) may have in relation to the trade
///
public IEnumerable PartyRole { get; }
///
/// The lineage attribute provides a linkage to previous lifecycle events and associated data.
///
public Lineage? Lineage { get; }
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AffirmationStatus Status { get; }
}
///
/// Represents a class to specify multiple credit notations alongside a conditional 'any' or 'all' qualifier.
///
public class AgencyRatingCriteria : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AgencyRatingCriteriaMeta();
[JsonConstructor]
public AgencyRatingCriteria(Enums.Quantifier qualifier, IEnumerable creditNotation, Enums.CreditNotationMismatchResolution? mismatchResolution, Enums.CreditRatingAgency? referenceAgency, Enums.CreditNotationBoundary? boundary)
{
Qualifier = qualifier;
CreditNotation = creditNotation;
MismatchResolution = mismatchResolution;
ReferenceAgency = referenceAgency;
Boundary = boundary;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Indicates whether all or any agency ratings apply.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.Quantifier Qualifier { get; }
///
/// Indicates the agency rating criteria specified for the asset or issuer.
///
public IEnumerable CreditNotation { get; }
///
/// Indicator for options to be used if several agency ratings (>1) are specified and its necessary to identify specific charateristics. i.e (lowest or highest).
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.CreditNotationMismatchResolution? MismatchResolution { get; }
///
/// identifies the dominant reference agency if there is a missmatch and several reference agencies exsist.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.CreditRatingAgency? ReferenceAgency { get; }
///
/// Indicates the boundary of a credit agency rating i.e minimum or maximum.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.CreditNotationBoundary? Boundary { get; }
}
///
/// Parameters to be used to filter events that are relevant to a given portfolio in order to calculate the state of this portfolio. The attributes correspond to all the possible aggregation criteria that can be used and these criteria can be combined. All the attributes are optional.
///
public class AggregationParameters : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AggregationParametersMeta();
[JsonConstructor]
public AggregationParameters(ZonedDateTime dateTime, bool? totalPosition, Enums.PositionStatus? positionStatus, IEnumerable party, IEnumerable product, IEnumerable productQualifier, IEnumerable tradeReference)
{
DateTime = dateTime;
TotalPosition = totalPosition;
PositionStatus = positionStatus;
Party = party;
Product = product;
ProductQualifier = productQualifier;
TradeReference = tradeReference;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// To aggregate as of a particular date
///
public ZonedDateTime DateTime { get; }
///
/// Specifies whether to calculate total position to given date, or only daily position for the given date.
///
public bool? TotalPosition { get; }
///
/// To aggregate based on position status (EXECUTED, SETTLED etc)
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.PositionStatus? PositionStatus { get; }
///
/// To aggregate based on a selection of party(ies) / legal entity(ies).
///
public IEnumerable Party { get; }
///
/// To aggregate based on a selection of products.
///
public IEnumerable Product { get; }
///
/// To aggregate based on a selection of product type(s).
///
public IEnumerable ProductQualifier { get; }
public IEnumerable TradeReference { get; }
}
///
/// Specification of the standard set of terms that define a legal agreement.
///
public class Agreement : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AgreementMeta();
[JsonConstructor]
public Agreement(CreditSupportAgreementElections? creditSupportAgreementElections, CollateralTransferAgreementElections? collateralTransferAgreementElections, SecurityAgreementElections? securityAgreementElections, MasterAgreementSchedule? masterAgreementSchedule, TransactionAdditionalTerms? transactionAdditionalTerms)
{
CreditSupportAgreementElections = creditSupportAgreementElections;
CollateralTransferAgreementElections = collateralTransferAgreementElections;
SecurityAgreementElections = securityAgreementElections;
MasterAgreementSchedule = masterAgreementSchedule;
TransactionAdditionalTerms = transactionAdditionalTerms;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Elections to specify a Credit Support Annex or Credit Support Deed for Intial or Variation Margin.
///
public CreditSupportAgreementElections? CreditSupportAgreementElections { get; }
///
/// Elections to specify a Collateral Transfer Agreement.
///
public CollateralTransferAgreementElections? CollateralTransferAgreementElections { get; }
///
/// Elections to specify a Security agreement.
///
public SecurityAgreementElections? SecurityAgreementElections { get; }
///
/// Elections to specify a Master Agreement Schedule.
///
public MasterAgreementSchedule? MasterAgreementSchedule { get; }
///
/// Any additional terms which mainly intend to specify the extraordinary events that may affect a trade and the related contractual rights and obligation of the parties when this happens
///
public TransactionAdditionalTerms? TransactionAdditionalTerms { get; }
}
///
/// Specifies the agreement name through an agreement type and optional detailed sub agreement type.
///
public class AgreementName : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AgreementNameMeta();
[JsonConstructor]
public AgreementName(Enums.LegalAgreementType agreementType, FieldWithMetaCreditSupportAgreementTypeEnum? creditSupportAgreementType, Enums.CollateralMarginType? creditSupportAgreementMarginType, IEnumerable contractualDefinitionsType, IEnumerable contractualTermsSupplement, IEnumerable contractualMatrix, FieldWithMetaMasterAgreementTypeEnum? masterAgreementType, FieldWithMetaMasterConfirmationTypeEnum? masterConfirmationType, FieldWithMetaMasterConfirmationAnnexTypeEnum? masterConfirmationAnnexType, string? otherAgreement)
{
AgreementType = agreementType;
CreditSupportAgreementType = creditSupportAgreementType;
CreditSupportAgreementMarginType = creditSupportAgreementMarginType;
ContractualDefinitionsType = contractualDefinitionsType;
ContractualTermsSupplement = contractualTermsSupplement;
ContractualMatrix = contractualMatrix;
MasterAgreementType = masterAgreementType;
MasterConfirmationType = masterConfirmationType;
MasterConfirmationAnnexType = masterConfirmationAnnexType;
OtherAgreement = otherAgreement;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specification of the legal agreement type.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.LegalAgreementType AgreementType { get; }
///
/// Specification of the credit support agreement type.
///
public FieldWithMetaCreditSupportAgreementTypeEnum? CreditSupportAgreementType { get; }
///
/// specifies the type of margin for which a legal agreement is named.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.CollateralMarginType? CreditSupportAgreementMarginType { get; }
///
/// The definitions such as those published by ISDA that will define the terms of the trade.
///
public IEnumerable ContractualDefinitionsType { get; }
///
/// A contractual supplement (such as those published by ISDA) that will apply to the trade.
///
public IEnumerable ContractualTermsSupplement { get; }
///
/// A reference to a contractual matrix of elected terms/values (such as those published by ISDA) that shall be deemed to apply to the trade. The applicable matrix is identified by reference to a name and optionally a publication date. Depending on the structure of the matrix, an additional term (specified in the matrixTerm element) may be required to further identify a subset of applicable terms/values within the matrix.
///
public IEnumerable ContractualMatrix { get; }
///
/// Specification of the master agreement type.
///
public FieldWithMetaMasterAgreementTypeEnum? MasterAgreementType { get; }
///
/// The type of master confirmation executed between the parties.
///
public FieldWithMetaMasterConfirmationTypeEnum? MasterConfirmationType { get; }
///
/// The type of master confirmation annex executed between the parties.
///
public FieldWithMetaMasterConfirmationAnnexTypeEnum? MasterConfirmationAnnexType { get; }
///
/// Definition of an agreement that is not enumerated in the CDM.
///
public string? OtherAgreement { get; }
}
///
/// Specification of the content of a legal agreement.
///
public class AgreementTerms : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AgreementTermsMeta();
[JsonConstructor]
public AgreementTerms(Agreement agreement, bool? clauseLibrary, IEnumerable counterparty)
{
Agreement = agreement;
ClauseLibrary = clauseLibrary;
Counterparty = counterparty;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specification of the standard set of terms that define a legal agreement.
///
public Agreement Agreement { get; }
///
/// Specification of whether the agreement terms have been negotiated using the clause library methodology.
///
public bool? ClauseLibrary { get; }
///
/// Specification of the roles of the counterparties to the agreement.
///
public IEnumerable Counterparty { get; }
}
///
/// A class defining the exercise period for an American style option together with any rules governing the notional amount of the underlying which can be exercised on any given exercise date and any associated exercise fees.
///
public class AmericanExercise : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AmericanExerciseMeta();
[JsonConstructor]
public AmericanExercise(AdjustableOrRelativeDate commencementDate, AdjustableOrRelativeDate expirationDate, AdjustableOrRelativeDates? relevantUnderlyingDate, BusinessCenterTime? earliestExerciseTime, BusinessCenterTime? latestExerciseTime, BusinessCenterTime expirationTime, Enums.ExpirationTimeType? expirationTimeType, MultipleExercise? multipleExercise, ExerciseFeeSchedule? exerciseFeeSchedule, _MetaFields? meta)
{
CommencementDate = commencementDate;
ExpirationDate = expirationDate;
RelevantUnderlyingDate = relevantUnderlyingDate;
EarliestExerciseTime = earliestExerciseTime;
LatestExerciseTime = latestExerciseTime;
ExpirationTime = expirationTime;
ExpirationTimeType = expirationTimeType;
MultipleExercise = multipleExercise;
ExerciseFeeSchedule = exerciseFeeSchedule;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The first day of the exercise period for an American style option.
///
public AdjustableOrRelativeDate CommencementDate { get; }
///
/// The last day within an exercise period for an American style option. For a European style option it is the only day within the exercise period.
///
public AdjustableOrRelativeDate ExpirationDate { get; }
///
/// The effective date on the underlying product if the option is exercised. For example, for a swaption it is the swap effective date, for an option on an FX spot or forward it is the value date for settlement, and in an extendible/cancelable provision it is the swap termination date, which is the date on which the termination is effective.'
///
public AdjustableOrRelativeDates? RelevantUnderlyingDate { get; }
///
/// The earliest time at which notice of exercise can be given by the buyer to the seller (or seller's agent) to, and including, the expiration date.
///
public BusinessCenterTime? EarliestExerciseTime { get; }
///
/// For a Bermuda or American style option, the latest time on an exercise business day (excluding the expiration date) within the exercise period that notice can be given by the buyer to the seller or seller's agent. Notice of exercise given after this time will be deemed to have been given on the next exercise business day.
///
public BusinessCenterTime? LatestExerciseTime { get; }
///
/// The latest time for exercise on expirationDate.
///
public BusinessCenterTime ExpirationTime { get; }
///
/// The time of day at which the equity option expires, for example the official closing time of the exchange.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.ExpirationTimeType? ExpirationTimeType { get; }
///
/// As defined in the 2000 ISDA Definitions, Section 12.4. Multiple Exercise, the buyer of the option has the right to exercise all or less than all the unexercised notional amount of the underlying swap on one or more days in the exercise period, but on any such day may not exercise less than the minimum notional amount or more that the maximum notional amount, and if an integral multiple amount is specified, the notional amount exercised must be equal to, or be an integral multiple of, the integral multiple amount.
///
public MultipleExercise? MultipleExercise { get; }
///
/// The fees associated with an exercise date. The fees are conditional on the exercise occurring. The fees can be specified as actual currency amounts or as percentages of the notional amount being exercised.
///
public ExerciseFeeSchedule? ExerciseFeeSchedule { get; }
public _MetaFields? Meta { get; }
}
///
/// A class to specify a currency amount or a currency amount schedule.
///
public class AmountSchedule : AbstractRosettaModelObject, ISchedule
{
private static readonly IRosettaMetaData metaData = new AmountScheduleMeta();
[JsonConstructor]
public AmountSchedule(IEnumerable currency, decimal value, IEnumerable datedValue)
{
Currency = currency;
Value = value;
DatedValue = datedValue;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The currency in which the amount schedule is denominated. The currency is specified outside of the actual schedule in order to be applied uniformly to it. The list of valid currencies is not presently positioned as an enumeration as part of the CDM because that scope is limited to the values specified by ISDA and FpML. As a result, implementers have to make reference to the relevant standard, such as the ISO 4217 standard for currency codes.
///
public IEnumerable Currency { get; }
///
public decimal Value { get; }
///
public IEnumerable DatedValue { get; }
}
///
/// Holds an identifier for an ancillary entity, either identified directly via its ancillary role or directly as a legal entity.
///
public class AncillaryEntity : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AncillaryEntityMeta();
[JsonConstructor]
public AncillaryEntity(Enums.AncillaryRole? ancillaryParty, LegalEntity? legalEntity)
{
AncillaryParty = ancillaryParty;
LegalEntity = legalEntity;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Identifies a party via its ancillary role on a transaction (e.g. CCP or DCO through which the trade should be cleared.)
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AncillaryRole? AncillaryParty { get; }
public LegalEntity? LegalEntity { get; }
}
///
/// Defines an ancillary role enumerated value with an associated party reference. The product is agnostic to the actual parties involved in the transaction, with the party references abstracted away from the product definition and replaced by the AncillaryRoleEnum. The AncillaryRoleEnum can then be positioned in the product and this AncillaryParty type, which is positioned outside of the product definition, allows the AncillaryRoleEnum to be associated with an actual party reference.
///
public class AncillaryParty : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AncillaryPartyMeta();
[JsonConstructor]
public AncillaryParty(Enums.AncillaryRole role, IEnumerable partyReference, Enums.CounterpartyRole? onBehalfOf)
{
Role = role;
PartyReference = partyReference;
OnBehalfOf = onBehalfOf;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specifies the AncillaryRoleEnum that is associated to the party reference. An ancillary party is any involved party that is not one of the two principal parties to the transaction.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AncillaryRole Role { get; }
///
/// Specifies the party, or parties, associated to the ancillary role.
///
public IEnumerable PartyReference { get; }
///
/// Optionally specifies the counterparty that the ancillary party is acting on behalf of.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.CounterpartyRole? OnBehalfOf { get; }
}
///
/// As per ISDA 2002 Definitions.
///
public class Asian : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AsianMeta();
[JsonConstructor]
public Asian(Enums.AveragingInOut averagingInOut, decimal? strikeFactor, AveragingPeriod? averagingPeriodIn, AveragingPeriod? averagingPeriodOut)
{
AveragingInOut = averagingInOut;
StrikeFactor = strikeFactor;
AveragingPeriodIn = averagingPeriodIn;
AveragingPeriodOut = averagingPeriodOut;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AveragingInOut AveragingInOut { get; }
///
/// The factor of strike.
///
public decimal? StrikeFactor { get; }
///
/// The averaging in period.
///
public AveragingPeriod? AveragingPeriodIn { get; }
///
/// The averaging out period.
///
public AveragingPeriod? AveragingPeriodOut { get; }
}
///
/// Represents a set of criteria used to specify eligible collateral assets.
///
public class AssetCriteria : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetCriteriaMeta();
[JsonConstructor]
public AssetCriteria(IEnumerable collateralAssetType, IEnumerable assetCountryOfOrigin, IEnumerable denominatedCurrency, IEnumerable agencyRating, Enums.MaturityType? maturityType, PeriodRange? maturityRange, IEnumerable productIdentifier, IEnumerable collateralTaxonomy, bool? domesticCurrencyIssued, ListingType? listing)
{
CollateralAssetType = collateralAssetType;
AssetCountryOfOrigin = assetCountryOfOrigin;
DenominatedCurrency = denominatedCurrency;
AgencyRating = agencyRating;
MaturityType = maturityType;
MaturityRange = maturityRange;
ProductIdentifier = productIdentifier;
CollateralTaxonomy = collateralTaxonomy;
DomesticCurrencyIssued = domesticCurrencyIssued;
Listing = listing;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Represents a filter based on the asset product type.
///
public IEnumerable CollateralAssetType { get; }
///
/// Represents a filter on the asset country of origin based on the ISO Standard 3166.
///
[JsonConverter(typeof(StringEnumConverter))]
public IEnumerable AssetCountryOfOrigin { get; }
///
/// Represents a filter on the underlying asset denominated currency based on ISO Standards.
///
[JsonConverter(typeof(StringEnumConverter))]
public IEnumerable DenominatedCurrency { get; }
///
/// Represents an agency rating based on default risk and creditors claim in event of default associated with specific instrument.
///
public IEnumerable AgencyRating { get; }
///
/// Specifies whether the maturity range is the remaining or original maturity.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.MaturityType? MaturityType { get; }
///
/// Represents a filter based on the underlying asset maturity.
///
public PeriodRange? MaturityRange { get; }
///
/// Represents a filter based on specific instrument identifiers (e.g. specific ISINs, CUSIPs etc).
///
public IEnumerable ProductIdentifier { get; }
///
/// Specifies the collateral taxonomy,which is composed of a taxonomy value and a taxonomy source.
///
public IEnumerable CollateralTaxonomy { get; }
///
/// Identifies that the Security must be denominated in the domestic currency of the issuer.
///
public bool? DomesticCurrencyIssued { get; }
///
/// Specifies the exchange, index or sector specific to listing of a security.
///
public ListingType? Listing { get; }
}
///
/// Contains the information relative to the delivery of the asset.
///
public class AssetDeliveryInformation : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetDeliveryInformationMeta();
[JsonConstructor]
public AssetDeliveryInformation(AssetDeliveryPeriods? periods, IEnumerable location, Quantity? deliveryCapacity)
{
Periods = periods;
Location = location;
DeliveryCapacity = deliveryCapacity;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Defines the periods of delivery, including the delivery profile.
///
public AssetDeliveryPeriods? Periods { get; }
///
/// Defines the location of the delivery of the commodity.
///
public IEnumerable Location { get; }
///
/// The number of units included in the transaction for each delivery interval
///
public Quantity? DeliveryCapacity { get; }
}
///
/// Defines the periods of delivery, including the delivery profile.
///
public class AssetDeliveryPeriods : AbstractRosettaModelObject, IAssetDeliveryPeriods
{
private static readonly IRosettaMetaData metaData = new AssetDeliveryPeriodsMeta();
[JsonConstructor]
public AssetDeliveryPeriods(IEnumerable profile, LocalDate? startDate, LocalDate? endDate)
{
Profile = profile;
StartDate = startDate;
EndDate = endDate;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
public IEnumerable Profile { get; }
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? StartDate { get; }
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? EndDate { get; }
}
///
/// Defines the delivery profile of the asset, including the load type and the delivery intervals.
///
public class AssetDeliveryProfile : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetDeliveryProfileMeta();
[JsonConstructor]
public AssetDeliveryProfile(Enums.LoadType? loadType, IEnumerable block, Enums.BankHolidayTreatment? bankHolidaysTreatment)
{
LoadType = loadType;
Block = block;
BankHolidaysTreatment = bankHolidaysTreatment;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Identification of the delivery profile.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.LoadType? LoadType { get; }
///
/// Defines a delivery profile block, including start and end time, days of the week, duration, delivery capacity and price time interval quantity.
///
public IEnumerable Block { get; }
///
/// Specifies whether the dates defined include holidays or not.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.BankHolidayTreatment? BankHolidaysTreatment { get; }
}
///
/// Defines a delivery profile block, including start and end time, days of the week, duration, delivery capacity and price time interval quantity.
///
public class AssetDeliveryProfileBlock : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetDeliveryProfileBlockMeta();
[JsonConstructor]
public AssetDeliveryProfileBlock(LocalTime? startTime, LocalTime? endTime, IEnumerable dayOfWeek, Quantity? deliveryCapacity, Price? priceTimeIntervalQuantity)
{
StartTime = startTime;
EndTime = endTime;
DayOfWeek = dayOfWeek;
DeliveryCapacity = deliveryCapacity;
PriceTimeIntervalQuantity = priceTimeIntervalQuantity;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The start time of the delivery interval for each block or shape.
///
public LocalTime? StartTime { get; }
///
/// The end time of the delivery interval for each block or shape.
///
public LocalTime? EndTime { get; }
///
/// The days of the week of the delivery.
///
[JsonConverter(typeof(StringEnumConverter))]
public IEnumerable DayOfWeek { get; }
///
/// The number of units included in the transaction for each delivery interval
///
public Quantity? DeliveryCapacity { get; }
///
/// Price per quantity per delivery time interval.
///
public Price? PriceTimeIntervalQuantity { get; }
}
///
/// Defines each asset movement of an asset payout.
///
public class AssetLeg : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetLegMeta();
[JsonConstructor]
public AssetLeg(AdjustableOrRelativeDate settlementDate, Enums.DeliveryMethod deliveryMethod)
{
SettlementDate = settlementDate;
DeliveryMethod = deliveryMethod;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specifies the settlement date of securities. In a repo transaction the purchase date would always be the effective date as specified under Economic Terms, the repurchase date would always be the termination date as specified under Economic Terms.
///
public AdjustableOrRelativeDate SettlementDate { get; }
///
/// Specifies a delivery method for the security transaction.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.DeliveryMethod DeliveryMethod { get; }
}
///
/// Security finance payout specification in case the product payout involves some form of security collateral, as in a securities financing transaction. Plus additional description for ICMA.
///
public class AssetPayout : AbstractRosettaModelObject, IPayoutBase
{
private static readonly IRosettaMetaData metaData = new AssetPayoutMeta();
[JsonConstructor]
public AssetPayout(IEnumerable assetLeg, Product securityInformation, Duration durationType, Money? minimumFee, DividendTerms? dividendTerms, _MetaFields? meta, PayerReceiver payerReceiver, ResolvablePriceQuantity? priceQuantity, PrincipalPayments? principalPayment, SettlementTerms? settlementTerms)
{
AssetLeg = assetLeg;
SecurityInformation = securityInformation;
DurationType = durationType;
MinimumFee = minimumFee;
DividendTerms = dividendTerms;
Meta = meta;
PayerReceiver = payerReceiver;
PriceQuantity = priceQuantity;
PrincipalPayment = principalPayment;
SettlementTerms = settlementTerms;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Defines each asset movement as a buy/sell at different dates, typically 1 near leg and 1 far leg in a securities financing transaction.
///
public IEnumerable AssetLeg { get; }
///
/// Specifies the Purchased Security. Within SecurityPayout we include a condition which validates that the product must be a Security (see below condition 'ProductMustBeSecurity').
///
public Product SecurityInformation { get; }
///
/// Specifies the Duration Terms of the Security Finance transaction. e.g. Open or Term.
///
public Duration DurationType { get; }
///
/// A contractual minimum amount which the borrower will pay, regardless of the duration of the loan. A mechanism for making sure that a trade generates enough income.
///
public Money? MinimumFee { get; }
///
/// Specifies the terms under which dividends received by the borrower are passed through to the lender.
///
public DividendTerms? DividendTerms { get; }
public _MetaFields? Meta { get; }
///
public PayerReceiver PayerReceiver { get; }
///
public ResolvablePriceQuantity? PriceQuantity { get; }
///
public PrincipalPayments? PrincipalPayment { get; }
///
public SettlementTerms? SettlementTerms { get; }
}
///
/// Characterizes the asset pool behind an asset backed bond.
///
public class AssetPool : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetPoolMeta();
[JsonConstructor]
public AssetPool(string? version, LocalDate? effectiveDate, decimal initialFactor, decimal? currentFactor)
{
Version = version;
EffectiveDate = effectiveDate;
InitialFactor = initialFactor;
CurrentFactor = currentFactor;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The asset pool version.
///
public string? Version { get; }
///
/// Optionally it is possible to specify a version effective date when a version is supplied.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate? EffectiveDate { get; }
///
/// The part of the mortgage that is outstanding on trade inception, i.e. has not been repaid yet as principal. It is expressed as a multiplier factor to the mortgage: 1 means that the whole mortgage amount is outstanding, 0.8 means that 20% has been repaid.
///
public decimal InitialFactor { get; }
///
/// The part of the mortgage that is currently outstanding. It is expressed similarly to the initial factor, as factor multiplier to the mortgage. This term is formally defined as part of the 'ISDA Standard Terms Supplement for use with credit derivatives transactions on mortgage-backed security with pas-as-you-go or physical settlement'.
///
public decimal? CurrentFactor { get; }
}
///
/// Represents a class to allow specification of the asset product type.
///
public class AssetType : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssetTypeMeta();
[JsonConstructor]
public AssetType(Enums.AssetType assetType, Enums.SecurityType? securityType, DebtType? debtType, Enums.EquityType? equityType, Enums.FundProductType? fundType, IEnumerable otherAssetType)
{
AssetTypeValue = assetType;
SecurityType = securityType;
DebtType = debtType;
EquityType = equityType;
FundType = fundType;
OtherAssetType = otherAssetType;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Represents a filter based on the type of collateral asset.
///
[JsonConverter(typeof(StringEnumConverter))]
[JsonProperty(PropertyName = "assetType")]
public Enums.AssetType AssetTypeValue { get; }
///
/// Represents a filter based on the type of security.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.SecurityType? SecurityType { get; }
///
/// Represents a filter based on the type of bond.
///
public DebtType? DebtType { get; }
///
/// Represents a filter based on the type of equity.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.EquityType? EquityType { get; }
///
/// Represents a filter based on the type of fund.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.FundProductType? FundType { get; }
///
/// Specifies the eligible asset type when not enumerated.
///
public IEnumerable OtherAssetType { get; }
}
///
/// A class to specify the identifier value and its associated version.
///
public class AssignedIdentifier : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AssignedIdentifierMeta();
[JsonConstructor]
public AssignedIdentifier(FieldWithMetaString identifier, int? version)
{
Identifier = identifier;
Version = version;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The identifier value.
///
public FieldWithMetaString Identifier { get; }
///
/// The identifier version, which is specified as an integer and is meant to be incremented each time the transaction terms (whether contract or event) change. This version is made option to support the use case where the identifier is referenced without the version. The constraint that a contract and a lifecycle event need to have an associated version is enforced through data rules.
///
public int? Version { get; }
}
///
/// A type to define automatic exercise of a swaption. With automatic exercise the option is deemed to have exercised if it is in the money by more than the threshold amount on the exercise date.
///
public class AutomaticExercise : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AutomaticExerciseMeta();
[JsonConstructor]
public AutomaticExercise(decimal? thresholdRate, bool? isApplicable)
{
ThresholdRate = thresholdRate;
IsApplicable = isApplicable;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A threshold rate. The threshold of 0.10% would be represented as 0.001
///
public decimal? ThresholdRate { get; }
///
/// Boolean that indicates if it has an automaticExercise
///
public bool? IsApplicable { get; }
}
///
/// A data type that can be used to describe the inventory of securities that a party holds. The securities are held in the AvailableInventoryRecord, with each item in the array being an individual security and its associated criteria. Criteria can include the quantity available, the rate at which the security is available to borrow at, as well as other details that can affect the decision as to whether a party wants to utilise the securities listed.
///
public class AvailableInventory : AbstractRosettaModelObject, IAvailableInventory
{
private static readonly IRosettaMetaData metaData = new AvailableInventoryMeta();
[JsonConstructor]
public AvailableInventory(MessageInformation? messageInformation, IEnumerable party, IEnumerable partyRole, IEnumerable availableInventoryRecord)
{
MessageInformation = messageInformation;
Party = party;
PartyRole = partyRole;
AvailableInventoryRecord = availableInventoryRecord;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
public MessageInformation? MessageInformation { get; }
///
public IEnumerable Party { get; }
///
public IEnumerable PartyRole { get; }
///
public IEnumerable AvailableInventoryRecord { get; }
}
///
/// An individual piece of available inventory. This represents a single security and its associated criteria. The criteria are used to describe any restrictions on the securities.
///
public class AvailableInventoryRecord : AbstractRosettaModelObject, IInventoryRecord
{
private static readonly IRosettaMetaData metaData = new AvailableInventoryRecordMeta();
[JsonConstructor]
public AvailableInventoryRecord(ZonedDateTime? expirationDateTime, IEnumerable collateral, IEnumerable partyRole, Quantity? availableQuantity, Price? interestRate, AssignedIdentifier identifer, Security security)
{
ExpirationDateTime = expirationDateTime;
Collateral = collateral;
PartyRole = partyRole;
AvailableQuantity = availableQuantity;
InterestRate = interestRate;
Identifer = identifer;
Security = security;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// There may be a set period/time restriction associated to the security.
///
public ZonedDateTime? ExpirationDateTime { get; }
///
/// The type of collateral can often be required when determining if the piece of availability being described is suitable for a party.
///
public IEnumerable Collateral { get; }
///
/// An individual security may be held by several agents. Including the party role at this level allows us to reference the party holding this specific item.
///
public IEnumerable PartyRole { get; }
///
/// The quantity of the security that is available
///
public Quantity? AvailableQuantity { get; }
///
/// An optional element which can be used to hold a rate associated to this piece of availability.
///
public Price? InterestRate { get; }
///
public AssignedIdentifier Identifer { get; }
///
public Security Security { get; }
}
///
/// Represents the average trading volume of an Equity product upon an exchange or set of exchanges.
///
public class AverageTradingVolume : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AverageTradingVolumeMeta();
[JsonConstructor]
public AverageTradingVolume(Period period, Enums.AverageTradingVolumeMethodology methodology)
{
Period = period;
Methodology = methodology;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Represents the period of the equities average trading volume on the exchange/s.
///
public Period Period { get; }
///
/// Indicates the type of equity average trading volume being stated (single) the highest amount on one exchange, or (consolidated) volumes across multiple exchanges.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AverageTradingVolumeMethodology Methodology { get; }
}
///
/// Defines parameters for use in cases when a valuation or other term is based on an average of market observations.
///
public class AveragingCalculation : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingCalculationMeta();
[JsonConstructor]
public AveragingCalculation(AveragingCalculationMethod averagingMethod, Rounding precision)
{
AveragingMethod = averagingMethod;
Precision = precision;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Specifies enumerations for the type of averaging calculation.
///
public AveragingCalculationMethod AveragingMethod { get; }
///
/// Rounding applied to the average calculation.
///
public Rounding Precision { get; }
}
///
/// Defines the ways in which multiple values can be aggregated into a single value.
///
public class AveragingCalculationMethod : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingCalculationMethodMeta();
[JsonConstructor]
public AveragingCalculationMethod(bool isWeighted, Enums.AveragingCalculationMethod calculationMethod)
{
IsWeighted = isWeighted;
CalculationMethod = calculationMethod;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Identifies whether the average values will be weighted or unweighted.
///
public bool IsWeighted { get; }
///
/// Identifies which of the Pythagorean means is being used to compute an average value.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.AveragingCalculationMethod CalculationMethod { get; }
}
///
/// An unordered list of weighted averaging observations.
///
public class AveragingObservationList : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingObservationListMeta();
[JsonConstructor]
public AveragingObservationList(IEnumerable averagingObservation)
{
AveragingObservation = averagingObservation;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A single weighted averaging observation.
///
public IEnumerable AveragingObservation { get; }
}
///
/// Period over which an average value is taken.
///
public class AveragingPeriod : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingPeriodMeta();
[JsonConstructor]
public AveragingPeriod(IEnumerable schedule, DateTimeList? averagingDateTimes, AveragingObservationList? averagingObservations, FieldWithMetaMarketDisruptionEnum? marketDisruption)
{
Schedule = schedule;
AveragingDateTimes = averagingDateTimes;
AveragingObservations = averagingObservations;
MarketDisruption = marketDisruption;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A schedule for generating averaging observation dates.
///
public IEnumerable Schedule { get; }
///
/// An unweighted list of averaging observation date and times.
///
public DateTimeList? AveragingDateTimes { get; }
///
/// A weighted list of averaging observation date and times.
///
public AveragingObservationList? AveragingObservations { get; }
///
/// The market disruption event as defined by ISDA 2002 Definitions.
///
public FieldWithMetaMarketDisruptionEnum? MarketDisruption { get; }
}
///
/// Class to representing a method for generating a series of dates.
///
public class AveragingSchedule : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingScheduleMeta();
[JsonConstructor]
public AveragingSchedule(LocalDate startDate, LocalDate endDate, CalculationPeriodFrequency averagingPeriodFrequency)
{
StartDate = startDate;
EndDate = endDate;
AveragingPeriodFrequency = averagingPeriodFrequency;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Date on which this period begins.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate StartDate { get; }
///
/// Date on which this period ends.
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate EndDate { get; }
///
/// The frequency at which averaging period occurs with the regular part of the valuation schedule and their roll date convention.
///
public CalculationPeriodFrequency AveragingPeriodFrequency { get; }
}
///
/// Defines the terms required to calculate the average observations associated with an averaging strike.
///
public class AveragingStrikeFeature : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new AveragingStrikeFeatureMeta();
[JsonConstructor]
public AveragingStrikeFeature(AveragingCalculation averagingCalculation, ObservationTerms observationTerms)
{
AveragingCalculation = averagingCalculation;
ObservationTerms = observationTerms;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Defines parameters for use in cases when a valuation or other term is based on an average of market observations.
///
public AveragingCalculation AveragingCalculation { get; }
///
/// Class containing terms that are associated with observing a price/benchmark/index across either single or multple observations.
///
public ObservationTerms ObservationTerms { get; }
}
///
/// As per ISDA 2002 Definitions.
///
public class Barrier : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BarrierMeta();
[JsonConstructor]
public Barrier(TriggerEvent? barrierCap, TriggerEvent? barrierFloor)
{
BarrierCap = barrierCap;
BarrierFloor = barrierFloor;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// A trigger level approached from beneath.
///
public TriggerEvent? BarrierCap { get; }
///
/// A trigger level approached from above.
///
public TriggerEvent? BarrierFloor { get; }
}
///
/// Defines a custom basket by referencing a product identifier and its consituents.
///
public class Basket : AbstractRosettaModelObject, IProductBase
{
private static readonly IRosettaMetaData metaData = new BasketMeta();
[JsonConstructor]
public Basket(IEnumerable basketConstituent, IEnumerable productTaxonomy, IEnumerable productIdentifier)
{
BasketConstituent = basketConstituent;
ProductTaxonomy = productTaxonomy;
ProductIdentifier = productIdentifier;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// Identifies the constituents of the basket
///
public IEnumerable BasketConstituent { get; }
///
public IEnumerable ProductTaxonomy { get; }
///
public IEnumerable ProductIdentifier { get; }
}
///
/// CDS Basket Reference Information.
///
public class BasketReferenceInformation : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BasketReferenceInformationMeta();
[JsonConstructor]
public BasketReferenceInformation(FieldWithMetaString? basketName, IEnumerable basketId, ReferencePool referencePool, int? nthToDefault, int? mthToDefault, Tranche? tranche)
{
BasketName = basketName;
BasketId = basketId;
ReferencePool = referencePool;
NthToDefault = nthToDefault;
MthToDefault = mthToDefault;
Tranche = tranche;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The name of the basket expressed as a free format string. FpML does not define usage rules for this element.
///
public FieldWithMetaString? BasketName { get; }
///
/// A CDS basket identifier.
///
public IEnumerable BasketId { get; }
///
/// This element contains all the reference pool items to define the reference entity and reference obligation(s) in the basket.
///
public ReferencePool ReferencePool { get; }
///
/// N th reference obligation to default triggers payout.
///
public int? NthToDefault { get; }
///
/// M th reference obligation to default to allow representation of N th to M th defaults.
///
public int? MthToDefault { get; }
///
/// This element contains CDS tranche terms.
///
public Tranche? Tranche { get; }
}
///
/// A class defining the Bermuda option exercise dates and the expiration date together with any rules governing the notional amount of the underlying which can be exercised on any given exercise date and any associated exercise fee.
///
public class BermudaExercise : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BermudaExerciseMeta();
[JsonConstructor]
public BermudaExercise(AdjustableOrRelativeDates bermudaExerciseDates, AdjustableOrRelativeDates? relevantUnderlyingDate, BusinessCenterTime earliestExerciseTime, BusinessCenterTime? latestExerciseTime, BusinessCenterTime expirationTime, Enums.ExpirationTimeType? expirationTimeType, MultipleExercise? multipleExercise, ExerciseFeeSchedule? exerciseFeeSchedule, _MetaFields? meta)
{
BermudaExerciseDates = bermudaExerciseDates;
RelevantUnderlyingDate = relevantUnderlyingDate;
EarliestExerciseTime = earliestExerciseTime;
LatestExerciseTime = latestExerciseTime;
ExpirationTime = expirationTime;
ExpirationTimeType = expirationTimeType;
MultipleExercise = multipleExercise;
ExerciseFeeSchedule = exerciseFeeSchedule;
Meta = meta;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The dates that define the Bermuda option exercise dates and the expiration date. The last specified date is assumed to be the expiration date. The dates can either be specified as a series of explicit dates and associated adjustments or as a series of dates defined relative to another schedule of dates, for example, the calculation period start dates. Where a relative series of dates are defined the first and last possible exercise dates can be separately specified.
///
public AdjustableOrRelativeDates BermudaExerciseDates { get; }
///
/// The effective date on the underlying product if the option is exercised. For example, for a swaption it is the swap effective date, for an option on an FX spot or forward it is the value date for settlement, and in an extendible/cancelable provision it is the swap termination date, which is the date on which the termination is effective.
///
public AdjustableOrRelativeDates? RelevantUnderlyingDate { get; }
///
/// The earliest time at which notice of exercise can be given by the buyer to the seller (or seller's agent) on each Bermuda option exercise date and the expiration date.
///
public BusinessCenterTime EarliestExerciseTime { get; }
///
/// For a Bermuda or American style option, the latest time on an exercise business day (excluding the expiration date) within the exercise period that notice can be given by the buyer to the seller or seller's agent. Notice of exercise given after this time will be deemed to have been given on the next exercise business day.
///
public BusinessCenterTime? LatestExerciseTime { get; }
///
/// The latest time for exercise on expirationDate.
///
public BusinessCenterTime ExpirationTime { get; }
///
/// The time of day at which the equity option expires, for example the official closing time of the exchange.
///
[JsonConverter(typeof(StringEnumConverter))]
public Enums.ExpirationTimeType? ExpirationTimeType { get; }
///
/// As defined in the 2000 ISDA Definitions, Section 12.4. Multiple Exercise, the buyer of the option has the right to exercise all or less than all the unexercised notional amount of the underlying swap on one or more days in the exercise period, but on any such day may not exercise less than the minimum notional amount or more that the maximum notional amount, and if an integral multiple amount is specified, the notional amount exercised must be equal to, or be an integral multiple of, the integral multiple amount.
///
public MultipleExercise? MultipleExercise { get; }
///
/// The fees associated with an exercise date. The fees are conditional on the exercise occurring. The fees can be specified as actual currency amounts or as percentages of the notional amount being exercised.
///
public ExerciseFeeSchedule? ExerciseFeeSchedule { get; }
public _MetaFields? Meta { get; }
}
///
/// Specifies the instructions for creation of a Security Lending billing invoice.
///
public class BillingInstruction : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BillingInstructionMeta();
[JsonConstructor]
public BillingInstruction(Party sendingParty, Party receivingParty, LocalDate billingStartDate, LocalDate billingEndDate, IEnumerable billingRecordInstruction, IEnumerable billingSummary)
{
SendingParty = sendingParty;
ReceivingParty = receivingParty;
BillingStartDate = billingStartDate;
BillingEndDate = billingEndDate;
BillingRecordInstruction = billingRecordInstruction;
BillingSummary = billingSummary;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The party issuing the invoice
///
public Party SendingParty { get; }
///
/// The party receiving the invoice
///
public Party ReceivingParty { get; }
///
/// The starting date of the period described by this invoice
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate BillingStartDate { get; }
///
/// The ending date of the period described by this invoice
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate BillingEndDate { get; }
///
/// Instructions for creating the billing records contained within the invoice
///
public IEnumerable BillingRecordInstruction { get; }
///
/// The billing summaries contained within the invoice
///
public IEnumerable BillingSummary { get; }
}
///
/// Specifies individual records within a billing invoice.
///
public class BillingRecord : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BillingRecordMeta();
[JsonConstructor]
public BillingRecord(ReferenceWithMetaTradeState tradeState, Transfer recordTransfer, LocalDate recordStartDate, LocalDate recordEndDate, Money? minimumFee)
{
TradeState = tradeState;
RecordTransfer = recordTransfer;
RecordStartDate = recordStartDate;
RecordEndDate = recordEndDate;
MinimumFee = minimumFee;
}
///
[JsonIgnore]
public override IRosettaMetaData MetaData => metaData;
///
/// The trade for the individual billing record.
///
public ReferenceWithMetaTradeState TradeState { get; }
///
/// The settlement terms for the billing record
///
public Transfer RecordTransfer { get; }
///
/// The starting date of the period described by this record
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate RecordStartDate { get; }
///
/// The ending date of the period described by this record
///
[JsonConverter(typeof(Rosetta.Lib.LocalDateConverter))]
public LocalDate RecordEndDate { get; }
///
/// Indicates the minimum fee amount applied to the billing record, if any.
///
public Money? MinimumFee { get; }
}
///
/// Specifies the instructions for creation of a billing record.
///
public class BillingRecordInstruction : AbstractRosettaModelObject
{
private static readonly IRosettaMetaData metaData = new BillingRecordInstructionMeta();
[JsonConstructor]
public BillingRecordInstruction(ReferenceWithMetaTradeState tradeState, IEnumerable observation, LocalDate recordStartDate, LocalDate recordEndDate, LocalDate settlementDate)
{
TradeState = tradeState;
Observation = observation;
RecordStartDate = recordStartDate;
RecordEndDate = recordEndDate;
SettlementDate = settlementDate;
}
///
