lusid-sdk 2.1.913__py3-none-any.whl → 2.1.915__py3-none-any.whl

lusid/models/credit_spread_curve_data.py

@@ -29,11 +29,11 @@ class CreditSpreadCurveData(ComplexMarketData):
     """
     base_date: datetime = Field(..., alias="baseDate", description="EffectiveAt date of the quoted rates")
     dom_ccy:  StrictStr = Field(...,alias="domCcy", description="Domestic currency of the curve") 
-    tenors: conlist(StrictStr) = Field(..., description="The tenors for which the rates apply For more information on tenors, see [knowledge base article KA-02097](https://support.lusid.com/knowledgebase/article/KA-02097)")
+    tenors: conlist(StrictStr) = Field(..., description="The tenors for which the rates apply  For more information on tenors, see [knowledge base article KA-02097](https://support.lusid.com/knowledgebase/article/KA-02097)")
     spreads: conlist(Union[StrictFloat, StrictInt]) = Field(..., description="Par spread quotes corresponding to the tenors.")
     recovery_rate: Union[StrictFloat, StrictInt] = Field(..., alias="recoveryRate", description="The recovery rate in default.")
-    reference_date: Optional[datetime] = Field(None, alias="referenceDate", description="If tenors are provided, this is the date against which the tenors will be resolved. This is of importance to CDX spread quotes, which are usually quoted in tenors relative to the CDX start date. In this case, the ReferenceDate would be equal to the CDX start date, and the BaseDate would be the date for which the spreads are valid. If not provided, this defaults to the BaseDate of the curve.")
-    maturities: Optional[conlist(datetime)] = Field(None, description="The maturity dates for which the rates apply. Either tenors or maturities should be provided, not both.")
+    reference_date: Optional[datetime] = Field(None, alias="referenceDate", description="If tenors are provided, this is the date against which the tenors will be resolved.  This is of importance to CDX spread quotes, which are usually quoted in tenors relative to the CDX start date.  In this case, the ReferenceDate would be equal to the CDX start date, and the BaseDate would be the date for which the spreads are valid.  If not provided, this defaults to the BaseDate of the curve.")
+    maturities: Optional[conlist(datetime)] = Field(None, description="The maturity dates for which the rates apply.  Either tenors or maturities should be provided, not both.")
     lineage:  Optional[StrictStr] = Field(None,alias="lineage", description="Description of the complex market data's lineage e.g. 'FundAccountant_GreenQuality'.") 
     market_data_options: Optional[MarketDataOptions] = Field(None, alias="marketDataOptions")
     market_data_type:  StrictStr = Field(...,alias="marketDataType", description="The available values are: DiscountFactorCurveData, EquityVolSurfaceData, FxVolSurfaceData, IrVolCubeData, OpaqueMarketData, YieldCurveData, FxForwardCurveData, FxForwardPipsCurveData, FxForwardTenorCurveData, FxForwardTenorPipsCurveData, FxForwardCurveByQuoteReference, CreditSpreadCurveData, EquityCurveByPricesData, ConstantVolatilitySurface") 

lusid/models/credit_support_annex.py

@@ -24,15 +24,15 @@ from lusid.models.resource_id import ResourceId
 
 class CreditSupportAnnex(BaseModel):
     """
-    Entity to capture the calculable and queryable methods and practices of determining and transferring collateral to a counterparty as part of margining of transactions. These typically come from a particular ISDA agreement that is in place between the two counterparties.  # noqa: E501
+    Entity to capture the calculable and queryable methods and practices of determining and transferring collateral  to a counterparty as part of margining of transactions. These typically come from a particular ISDA agreement  that is in place between the two counterparties.  # noqa: E501
     """
-    reference_currency:  StrictStr = Field(...,alias="referenceCurrency", description="The base, or reference, currency against which MtM value and exposure should be calculated and in which the CSA parameters are defined if the currency is not otherwise explicitly stated.") 
+    reference_currency:  StrictStr = Field(...,alias="referenceCurrency", description="The base, or reference, currency against which MtM value and exposure should be calculated  and in which the CSA parameters are defined if the currency is not otherwise explicitly stated.") 
     collateral_currencies: conlist(StrictStr) = Field(..., alias="collateralCurrencies", description="The set of currencies within which it is acceptable to post cash collateral.")
-    isda_agreement_version:  StrictStr = Field(...,alias="isdaAgreementVersion", description="The transactions will take place with reference to a particular ISDA master agreement. This will likely be either the ISDA 1992 or ISDA 2002 agremeents or ISDA close-out 2009.") 
-    margin_call_frequency:  StrictStr = Field(...,alias="marginCallFrequency", description="The tenor, e.g. daily (1D) or biweekly (2W), at which frequency a margin call will be made, calculations made and money transferred to readjust. The calculation might also require a specific time for valuation and notification.") 
+    isda_agreement_version:  StrictStr = Field(...,alias="isdaAgreementVersion", description="The transactions will take place with reference to a particular ISDA master agreement. This  will likely be either the ISDA 1992 or ISDA 2002 agremeents or ISDA close-out 2009.") 
+    margin_call_frequency:  StrictStr = Field(...,alias="marginCallFrequency", description="The tenor, e.g. daily (1D) or biweekly (2W), at which frequency a margin call will be made, calculations  made and money transferred to readjust. The calculation might also require a specific time for valuation and notification.") 
     valuation_agent:  StrictStr = Field(...,alias="valuationAgent", description="Are the calculations performed by the institutions's counterparty or the institution trading with them.") 
-    threshold_amount: Union[StrictFloat, StrictInt] = Field(..., alias="thresholdAmount", description="At what level of exposure does collateral need to be posted. Will typically be zero for banks. Should be stated in reference currency")
-    rounding_decimal_places: StrictInt = Field(..., alias="roundingDecimalPlaces", description="Where a calculation needs to be rounded to a specific number of decimal places, this states the number that that requires.")
+    threshold_amount: Union[StrictFloat, StrictInt] = Field(..., alias="thresholdAmount", description="At what level of exposure does collateral need to be posted. Will typically be zero for banks.  Should be stated in reference currency")
+    rounding_decimal_places: StrictInt = Field(..., alias="roundingDecimalPlaces", description="Where a calculation needs to be rounded to a specific number of decimal places,  this states the number that that requires.")
     initial_margin_amount: Union[StrictFloat, StrictInt] = Field(..., alias="initialMarginAmount", description="The initial margin that is required. In the reference currency")
     minimum_transfer_amount: Union[StrictFloat, StrictInt] = Field(..., alias="minimumTransferAmount", description="The minimum amount, in the reference currency, that must be transferred when required.")
     id: ResourceId = Field(...)

lusid/models/curve_options.py

@@ -27,8 +27,8 @@ class CurveOptions(MarketDataOptions):
     Options for configuring how ComplexMarketData representing a 'curve' is interpreted.  # noqa: E501
     """
     day_count_convention:  Optional[StrictStr] = Field(None,alias="dayCountConvention", description="Day count convention of the curve. Defaults to \"Act360\".") 
-    front_extrapolation_type:  Optional[StrictStr] = Field(None,alias="frontExtrapolationType", description="What type of extrapolation is used to build the curve Imagine that the curve is facing the observer(you), then the \"front\" direction is the closest point on the curve onward.  example: 0D tenor to past Defaults to \"Flat\". Supported string (enumeration) values are: [None, Flat, Linear].") 
-    back_extrapolation_type:  Optional[StrictStr] = Field(None,alias="backExtrapolationType", description="What type of extrapolation is used to build the curve.  Imagine that the curve is facing the observer(you), then the \"back\" direction is the furthest point on the curve onward. example: 30Y tenor to infinity  Defaults to \"Flat\". Supported string (enumeration) values are: [None, Flat, Linear].") 
+    front_extrapolation_type:  Optional[StrictStr] = Field(None,alias="frontExtrapolationType", description="What type of extrapolation is used to build the curve  Imagine that the curve is facing the observer(you), then the \"front\" direction is the closest point on the curve onward.    example: 0D tenor to past  Defaults to \"Flat\". Supported string (enumeration) values are: [None, Flat, Linear].") 
+    back_extrapolation_type:  Optional[StrictStr] = Field(None,alias="backExtrapolationType", description="What type of extrapolation is used to build the curve.    Imagine that the curve is facing the observer(you), then the \"back\" direction is the furthest point on the curve onward.  example: 30Y tenor to infinity    Defaults to \"Flat\". Supported string (enumeration) values are: [None, Flat, Linear].") 
     market_data_options_type:  StrictStr = Field(...,alias="marketDataOptionsType", description="The available values are: CurveOptions") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["marketDataOptionsType", "dayCountConvention", "frontExtrapolationType", "backExtrapolationType"]

lusid/models/data_definition.py

@@ -23,12 +23,12 @@ from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictBool, StrictSt
 
 class DataDefinition(BaseModel):
     """
-    When importing data from an external data source, in order for it to be reliable queryable, LUSID needs to know something about it. A data definition tells LUSID, what a given external data item is, what type it is and whether it in some way identifies items of data. Consider presenting LUSID with a list of dictionaries where each dictionary contains the same set of keys (names). Each data item pointed to by a key would be expected to be of the same type (integer, string, decimal etc.). To identify a particular dictionary from the list, a tuple of one or more of the items in the dictionary would make it unique. If only a single item is required then the  # noqa: E501
+    When importing data from an external data source, in order for it to be reliable queryable, LUSID needs to know something about it.  A data definition tells LUSID, what a given external data item is, what type it is and whether it in some way identifies items of data.  Consider presenting LUSID with a list of dictionaries where each dictionary contains the same set of keys (names). Each data item pointed to by  a key would be expected to be of the same type (integer, string, decimal etc.). To identify a particular dictionary from the list, a tuple of  one or more of the items in the dictionary would make it unique. If only a single item is required then the  # noqa: E501
     """
     address:  StrictStr = Field(...,alias="address", description="The internal address (LUSID native) of the unit in the provided data itself and corresponds to the external name of the data item") 
     name:  Optional[StrictStr] = Field(None,alias="name", description="The name of the data item. This is the name that will appear") 
-    data_type:  Optional[StrictStr] = Field(None,alias="dataType", description="A member of the set of possible data types, that all data passed under that key is expected to be of. Currently limited to one of [string, integer, decimal, result0d].") 
-    key_type:  Optional[StrictStr] = Field(None,alias="keyType", description="Is the item either a unique key for the dictionary, i.e. does it identify a unique index or conceptual 'row' within the list of dictionaries, or a partial key or is it simply a data item within that dictionary. Must be one of [Unique,PartOfUnique,Leaf, CompositeLeaf]") 
+    data_type:  Optional[StrictStr] = Field(None,alias="dataType", description="A member of the set of possible data types, that all data passed under that key is expected to be of.  Currently limited to one of [string, integer, decimal, result0d].") 
+    key_type:  Optional[StrictStr] = Field(None,alias="keyType", description="Is the item either a unique key for the dictionary, i.e. does it identify a unique index or conceptual 'row' within the list of dictionaries,  or a partial key or is it simply a data item within that dictionary. Must be one of [Unique,PartOfUnique,Leaf, CompositeLeaf]") 
     allow_null: Optional[StrictBool] = Field(None, alias="allowNull", description="The path to the field must exist (unless AllowMissing is true) but the actual value is allowed to be null.")
     allow_missing: Optional[StrictBool] = Field(None, alias="allowMissing", description="The path (or column) is allowed to be missing but if it is present it is not allowed to be null unless AllowNull is true.")
     __properties = ["address", "name", "dataType", "keyType", "allowNull", "allowMissing"]

lusid/models/data_map_key.py

@@ -25,7 +25,7 @@ class DataMapKey(BaseModel):
     """
     DataMapKey
     """
-    version:  Optional[StrictStr] = Field(None,alias="version", description="The version of the mappings. It is possible that a client will wish to update mappings over time. The version identifies the MAJOR.MINOR.PATCH version of the mappings that the client assigns it.") 
+    version:  Optional[StrictStr] = Field(None,alias="version", description="The version of the mappings. It is possible that a client will wish to update mappings over time. The version identifies the MAJOR.MINOR.PATCH version  of the mappings that the client assigns it.") 
     code:  Optional[StrictStr] = Field(None,alias="code", description="A unique name to semantically identify the mapping set.") 
     __properties = ["version", "code"]
 

lusid/models/data_mapping.py

@@ -24,7 +24,7 @@ from lusid.models.data_definition import DataDefinition
 
 class DataMapping(BaseModel):
     """
-    When importing data from an external source there are essentially three levels of interaction with LUSID. (1) The data is a raw document that LUSID does not understand. You can store and retrieve it but it does not full interact with other documents inside LUSID (2) The data has a map from fields and paths to 'properties' in LUSID. In essence, LUSID can then treat the data as weakly typed (decimal, string) data that can be returned through queries     and where various aggregation requests will then work. (3) The data is fully translatable into LUSID and understood, in some sense, natively. This means that it can be used for context sensitive calculations such as pricing or risk calculations. The data map object is designed to allow data to transition from step 1 to 2 and in some cases as an alternative for step 2 to 3.  # noqa: E501
+    When importing data from an external source there are essentially three levels of interaction with LUSID.  (1) The data is a raw document that LUSID does not understand. You can store and retrieve it but it does not full interact with other documents inside LUSID  (2) The data has a map from fields and paths to 'properties' in LUSID. In essence, LUSID can then treat the data as weakly typed (decimal, string) data that can be returned through queries      and where various aggregation requests will then work.  (3) The data is fully translatable into LUSID and understood, in some sense, natively. This means that it can be used for context sensitive calculations such as pricing or risk calculations.  The data map object is designed to allow data to transition from step 1 to 2 and in some cases as an alternative for step 2 to 3.  # noqa: E501
     """
     data_definitions: Optional[conlist(DataDefinition)] = Field(None, alias="dataDefinitions", description="A map from LUSID item keys to data definitions that define the names, types and degree of uniqueness of data provided to LUSID in structured data stores.")
     __properties = ["dataDefinitions"]

lusid/models/dependency_source_filter.py

@@ -24,13 +24,13 @@ from lusid.models.address_key_filter import AddressKeyFilter
 
 class DependencySourceFilter(BaseModel):
     """
-    Encapsulates parts of a market data rule relating not to the nature of the market data requested, but rather the nature of the thing (instrument/model) that is requesting it. In the first instance, this includes the instrument type, asset class, and the currency of the underlying instrument. This can be used to differentiate requests for market data according to the source of the request. See MarketDataSpecificRule.  # noqa: E501
+    Encapsulates parts of a market data rule relating not to the nature of the market data requested, but rather the nature of the thing (instrument/model) that is requesting it.  In the first instance, this includes the instrument type, asset class, and the currency of the underlying instrument.  This can be used to differentiate requests for market data according to the source of the request. See MarketDataSpecificRule.  # noqa: E501
     """
-    instrument_type:  Optional[StrictStr] = Field(None,alias="instrumentType", description="Specify that a rule should only apply if the market data is requested by an instrument of a given instrument type. If null, then no filtering on instrument type is applied.") 
-    asset_class:  Optional[StrictStr] = Field(None,alias="assetClass", description="Specify that a rule should only apply if the market data is requested by an instrument of a given asset class. If null, then no filtering on asset class is applied.") 
-    dom_ccy:  Optional[StrictStr] = Field(None,alias="domCcy", description="Specify that a rule should only apply if the market data is requested by an instrument with a given domestic currency. If null, then no filtering on currency is applied.") 
-    long_or_short_indicator:  Optional[StrictStr] = Field(None,alias="longOrShortIndicator", description="Specify that a rule should apply if the market data is requested by a model with a given long or short indicator. If none, then no filtering on LongOrShortIndicator is applied.") 
-    address_key_filters: Optional[conlist(AddressKeyFilter)] = Field(None, alias="addressKeyFilters", description="Specify that a rule should apply if the market data is requested by an instrument with features or properties satisfying all the given address key filters. If an empty list is given, no additional filtering is done.")
+    instrument_type:  Optional[StrictStr] = Field(None,alias="instrumentType", description="Specify that a rule should only apply if the market data is requested by an instrument of a given instrument type.  If null, then no filtering on instrument type is applied.") 
+    asset_class:  Optional[StrictStr] = Field(None,alias="assetClass", description="Specify that a rule should only apply if the market data is requested by an instrument of a given asset class.  If null, then no filtering on asset class is applied.") 
+    dom_ccy:  Optional[StrictStr] = Field(None,alias="domCcy", description="Specify that a rule should only apply if the market data is requested by an instrument with a given domestic currency.  If null, then no filtering on currency is applied.") 
+    long_or_short_indicator:  Optional[StrictStr] = Field(None,alias="longOrShortIndicator", description="Specify that a rule should apply if the market data is requested by a model with a given long or short indicator.  If none, then no filtering on LongOrShortIndicator is applied.") 
+    address_key_filters: Optional[conlist(AddressKeyFilter)] = Field(None, alias="addressKeyFilters", description="Specify that a rule should apply if the market data is requested by an instrument with features or properties  satisfying all the given address key filters. If an empty list is given, no additional filtering is done.")
     __properties = ["instrumentType", "assetClass", "domCcy", "longOrShortIndicator", "addressKeyFilters"]
 
     class Config:

lusid/models/dialect.py

@@ -26,7 +26,7 @@ from lusid.models.version import Version
 
 class Dialect(BaseModel):
     """
-    The language/format of a translatable entity. Entities can be LUSID native or external and the Dialect describes 1) the system that understands the entity and 2) applicable validation for the entity, in the form of a schema.  # noqa: E501
+    The language/format of a translatable entity. Entities can be LUSID native or external and the Dialect describes  1) the system that understands the entity and  2) applicable validation for the entity, in the form of a schema.  # noqa: E501
     """
     id: DialectId = Field(...)
     var_schema: DialectSchema = Field(..., alias="schema")

lusid/models/dialect_schema.py

@@ -23,7 +23,7 @@ from pydantic.v1 import StrictStr, Field, BaseModel, Field, constr
 
 class DialectSchema(BaseModel):
     """
-    A schema that a given document must obey. A representation of the validation of a particular Dialect, in a given language.  # noqa: E501
+    A schema that a given document must obey. A representation of the validation of a particular Dialect,  in a given language.  # noqa: E501
     """
     type:  StrictStr = Field(...,alias="type", description="The type of schema this represents") 
     body:  Optional[StrictStr] = Field(None,alias="body", description="The body of the schema") 

lusid/models/discounting_dependency.py

@@ -24,10 +24,10 @@ from lusid.models.economic_dependency import EconomicDependency
 
 class DiscountingDependency(EconomicDependency):
     """
-    For indicating a dependency on discounting for a given currency. E.g Valuing a Bond with the Discounting model will declare a DiscountingDependency for the domestic currency of the bond to account for the time-value of the future cashFlows of the bond.  # noqa: E501
+    For indicating a dependency on discounting for a given currency.  E.g Valuing a Bond with the Discounting model will declare a DiscountingDependency  for the domestic currency of the bond to account for the time-value of the future cashFlows of the bond.  # noqa: E501
     """
     currency:  StrictStr = Field(...,alias="currency", description="The currency that needs to be discounted.") 
-    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for. Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
+    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for.  Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
     dependency_type:  StrictStr = Field(...,alias="dependencyType", description="The available values are: OpaqueDependency, CashDependency, DiscountingDependency, EquityCurveDependency, EquityVolDependency, FxDependency, FxForwardsDependency, FxVolDependency, IndexProjectionDependency, IrVolDependency, QuoteDependency, Vendor, CalendarDependency, InflationFixingDependency") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["dependencyType", "currency", "date"]

lusid/models/dividend_option_event.py

@@ -30,7 +30,7 @@ class DividendOptionEvent(InstrumentEvent):
     """
     announcement_date: Optional[datetime] = Field(None, alias="announcementDate", description="Date on which the dividend was announced / declared.")
     cash_elections: conlist(CashElection) = Field(..., alias="cashElections", description="CashElection for this DividendReinvestmentEvent")
-    ex_date: Optional[datetime] = Field(None, alias="exDate", description="The first business day on which the dividend is not owed to the buying party. Typically this is T-1 from the RecordDate.")
+    ex_date: Optional[datetime] = Field(None, alias="exDate", description="The first business day on which the dividend is not owed to the buying party.  Typically this is T-1 from the RecordDate.")
     payment_date: Optional[datetime] = Field(None, alias="paymentDate", description="The date the company pays out dividends to shareholders.")
     record_date: Optional[datetime] = Field(None, alias="recordDate", description="Date you have to be the holder of record in order to participate in the tender.")
     security_elections: conlist(SecurityElection) = Field(..., alias="securityElections", description="SecurityElection for this DividendReinvestmentEvent")

lusid/models/dividend_reinvestment_event.py

@@ -30,7 +30,7 @@ class DividendReinvestmentEvent(InstrumentEvent):
     """
     announcement_date: Optional[datetime] = Field(None, alias="announcementDate", description="Date on which the dividend was announced / declared.")
     cash_elections: conlist(CashElection) = Field(..., alias="cashElections", description="CashElection for this DividendReinvestmentEvent")
-    ex_date: Optional[datetime] = Field(None, alias="exDate", description="The first business day on which the dividend is not owed to the buying party. Typically this is T-1 from the RecordDate.")
+    ex_date: Optional[datetime] = Field(None, alias="exDate", description="The first business day on which the dividend is not owed to the buying party.  Typically this is T-1 from the RecordDate.")
     payment_date: Optional[datetime] = Field(None, alias="paymentDate", description="The date the company pays out dividends to shareholders.")
     record_date: Optional[datetime] = Field(None, alias="recordDate", description="Date you have to be the holder of record in order to participate in the tender.")
     security_elections: conlist(SecurityElection) = Field(..., alias="securityElections", description="SecurityElection for this DividendReinvestmentEvent")

lusid/models/early_redemption_election.py

@@ -26,7 +26,7 @@ class EarlyRedemptionElection(BaseModel):
     EarlyRedemptionElection for EarlyRedemptionEvent  # noqa: E501
     """
     election_key:  StrictStr = Field(...,alias="electionKey", description="Unique key associated to this election") 
-    is_default: Optional[StrictBool] = Field(None, alias="isDefault", description="Is this election automatically applied in the absence of an election having been made. May only be true for one election if multiple are provided.")
+    is_default: Optional[StrictBool] = Field(None, alias="isDefault", description="Is this election automatically applied in the absence of an election having been made.  May only be true for one election if multiple are provided.")
     is_chosen: Optional[StrictBool] = Field(None, alias="isChosen", description="Is this the election that has been explicitly chosen from multiple options.")
     __properties = ["electionKey", "isDefault", "isChosen"]
 

lusid/models/early_redemption_event.py

@@ -27,12 +27,12 @@ class EarlyRedemptionEvent(InstrumentEvent):
     """
     Early redemption as a consequence of a bond being called or putted.  # noqa: E501
     """
-    effective_date: Optional[datetime] = Field(None, alias="effectiveDate", description="Date of redemption. For internally generated European callables, this is set to the exercise date. For internally generated American callables, this is set to the start of the exercise period.")
+    effective_date: Optional[datetime] = Field(None, alias="effectiveDate", description="Date of redemption.  For internally generated European callables, this is set to the exercise date.  For internally generated American callables, this is set to the start of the exercise period.")
     currency:  StrictStr = Field(...,alias="currency", description="Currency of the redemption.") 
     early_redemption_elections: conlist(EarlyRedemptionElection) = Field(..., alias="earlyRedemptionElections", description="EarlyRedemptionElection for the redemption.  Used to trigger the redemption.")
     redemption_percentage: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="redemptionPercentage", description="Percentage of the original issue that is redeemed, where 0.5 implies 50%.  Defaults to 1 if not set.  Must be between 0 and 1.")
     price_per_unit: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="pricePerUnit", description="The price, or strike, that each unit is redeemed at.")
-    accrued_interest_per_unit: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="accruedInterestPerUnit", description="Unpaid accrued interest also repaid as part of the redemption, per unit. Optional field. If left empty, will be resolved internally by calculating the accrued owed on the EffectiveDate. This process may require additional market data.")
+    accrued_interest_per_unit: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="accruedInterestPerUnit", description="Unpaid accrued interest also repaid as part of the redemption, per unit.  Optional field.  If left empty, will be resolved internally by calculating the accrued owed on the EffectiveDate.  This process may require additional market data.")
     instrument_event_type:  StrictStr = Field(...,alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent, BondCouponEvent, DividendReinvestmentEvent, AccumulationEvent, BondPrincipalEvent, DividendOptionEvent, MaturityEvent, FxForwardSettlementEvent, ExpiryEvent, ScripDividendEvent, StockDividendEvent, ReverseStockSplitEvent, CapitalDistributionEvent, SpinOffEvent, MergerEvent, FutureExpiryEvent, SwapCashFlowEvent, SwapPrincipalEvent, CreditPremiumCashFlowEvent, CdsCreditEvent, CdxCreditEvent, MbsCouponEvent, MbsPrincipalEvent, BonusIssueEvent, MbsPrincipalWriteOffEvent, MbsInterestDeferralEvent, MbsInterestShortfallEvent, TenderEvent, CallOnIntermediateSecuritiesEvent, IntermediateSecuritiesDistributionEvent, OptionExercisePhysicalEvent, OptionExerciseCashEvent, ProtectionPayoutCashFlowEvent, TermDepositInterestEvent, TermDepositPrincipalEvent, EarlyRedemptionEvent, FutureMarkToMarketEvent, AdjustGlobalCommitmentEvent, ContractInitialisationEvent, DrawdownEvent, LoanInterestRepaymentEvent, UpdateDepositAmountEvent, LoanPrincipalRepaymentEvent, DepositInterestPaymentEvent, DepositCloseEvent, LoanFacilityContractRolloverEvent, RepurchaseOfferEvent, RepoPartialClosureEvent, RepoCashFlowEvent, FlexibleRepoInterestPaymentEvent, FlexibleRepoCashFlowEvent, FlexibleRepoCollateralEvent, ConversionEvent, FlexibleRepoPartialClosureEvent, FlexibleRepoFullClosureEvent") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["instrumentEventType", "effectiveDate", "currency", "earlyRedemptionElections", "redemptionPercentage", "pricePerUnit", "accruedInterestPerUnit"]

lusid/models/economic_dependency.py

@@ -24,7 +24,7 @@ import lusid.models
 
 class EconomicDependency(BaseModel):
     """
-    Base class for representing economic dependencies. Economic dependencies are a way of indicating how one concept depends upon another. For example, when pricing an instrument with a particular model, that model will declare that it has an EconomicDependency for each bit of market data that it needs to complete the calculation. Concretely, a pricing an FxForward will declare a dependency on the exchange rate between the two currencies at the forward date.              Another example is when data is included in a data-structure only by reference. Concretely, an object depending on a FlowConvention that is referenced only semantically via a FlowConventionName will declare a FlowConventionDependency so that the full data-structure of the referenced FlowConvention can be retrieved.              For deserialization purposes, this class contains a discriminator EconomicDependencyType to indicate the derived type.  # noqa: E501
+    Base class for representing economic dependencies.  Economic dependencies are a way of indicating how one concept depends upon another.  For example, when pricing an instrument with a particular model,  that model will declare that it has an EconomicDependency for each bit of market data  that it needs to complete the calculation.  Concretely, a pricing an FxForward will declare a dependency on the exchange rate between the two currencies  at the forward date.                Another example is when data is included in a data-structure only by reference.  Concretely, an object depending on a FlowConvention that is referenced only semantically via a FlowConventionName  will declare a FlowConventionDependency  so that the full data-structure of the referenced FlowConvention can be retrieved.                For deserialization purposes,  this class contains a discriminator EconomicDependencyType to indicate the derived type.  # noqa: E501
     """
     dependency_type:  StrictStr = Field(...,alias="dependencyType", description="The available values are: OpaqueDependency, CashDependency, DiscountingDependency, EquityCurveDependency, EquityVolDependency, FxDependency, FxForwardsDependency, FxVolDependency, IndexProjectionDependency, IrVolDependency, QuoteDependency, Vendor, CalendarDependency, InflationFixingDependency") 
     __properties = ["dependencyType"]

lusid/models/equity.py

@@ -31,7 +31,7 @@ class Equity(LusidInstrument):
     """
     identifiers: Optional[EquityAllOfIdentifiers] = None
     dom_ccy:  StrictStr = Field(...,alias="domCcy", description="The domestic currency of the instrument.") 
-    lot_size: Optional[StrictInt] = Field(None, alias="lotSize", description="Deprecated: Use TradingConventions field instead Equity LotSize, the minimum number of shares that can be bought at once. Optional, if set must be non-negative, if not set defaults to 1.  Note this property does not impact valuation. From a LUSID analytics perspective, it is purely informational.")
+    lot_size: Optional[StrictInt] = Field(None, alias="lotSize", description="Deprecated: Use TradingConventions field instead  Equity LotSize, the minimum number of shares that can be bought at once.  Optional, if set must be non-negative, if not set defaults to 1.    Note this property does not impact valuation. From a LUSID analytics perspective, it is purely informational.")
     time_zone_conventions: Optional[TimeZoneConventions] = Field(None, alias="timeZoneConventions")
     trading_conventions: Optional[TradingConventions] = Field(None, alias="tradingConventions")
     instrument_type:  StrictStr = Field(...,alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg, FundShareClass, FlexibleLoan, UnsettledCash, Cash, MasteredInstrument, LoanFacility, FlexibleDeposit, FlexibleRepo") 

lusid/models/equity_curve_by_prices_data.py

@@ -28,7 +28,7 @@ class EquityCurveByPricesData(ComplexMarketData):
     Contains data (i.e. dates and prices + metadata) for building Equity curves  # noqa: E501
     """
     base_date: datetime = Field(..., alias="baseDate", description="EffectiveAt date of the provided prices")
-    dates: conlist(datetime) = Field(..., description="Dates provided for the forward price of the Equity at the corresponding price in Prices. These dates should be in the future with respect to the BaseDate.")
+    dates: conlist(datetime) = Field(..., description="Dates provided for the forward price of the Equity at the corresponding price in Prices.  These dates should be in the future with respect to the BaseDate.")
     lineage:  Optional[StrictStr] = Field(None,alias="lineage", description="Description of the complex market data's lineage e.g. 'FundAccountant_GreenQuality'.") 
     prices: conlist(Union[StrictFloat, StrictInt]) = Field(..., description="Prices provided for the forward price of the Equity at the corresponding date in Dates.")
     market_data_options: Optional[MarketDataOptions] = Field(None, alias="marketDataOptions")

lusid/models/equity_curve_dependency.py

@@ -24,12 +24,12 @@ from lusid.models.economic_dependency import EconomicDependency
 
 class EquityCurveDependency(EconomicDependency):
     """
-    For indicating a dependency on an EquityCurve. E.g. When pricing an EquitySwap one may want to make predictions about the price of the underlying equity at future dates. If so, that model would declare an EquityCurve dependency so that it could obtain predictions from the EquityCurve.  # noqa: E501
+    For indicating a dependency on an EquityCurve.  E.g. When pricing an EquitySwap one may want to make predictions about the price of the underlying equity at future dates.  If so, that model would declare an EquityCurve dependency so that it could obtain predictions from the EquityCurve.  # noqa: E501
     """
     market_identifier:  StrictStr = Field(...,alias="marketIdentifier", description="Type of the code identifying the corresponding equity, e.g. ISIN or CUSIP") 
     code:  StrictStr = Field(...,alias="code", description="The code identifying the corresponding equity, e.g. US0378331005 if the MarketIdentifier was set to ISIN") 
     curve_type:  StrictStr = Field(...,alias="curveType", description="The curve type of the EquityCurve required. E.g. EquityCurveByPrices") 
-    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for. Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
+    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for.  Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
     dependency_type:  StrictStr = Field(...,alias="dependencyType", description="The available values are: OpaqueDependency, CashDependency, DiscountingDependency, EquityCurveDependency, EquityVolDependency, FxDependency, FxForwardsDependency, FxVolDependency, IndexProjectionDependency, IrVolDependency, QuoteDependency, Vendor, CalendarDependency, InflationFixingDependency") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["dependencyType", "marketIdentifier", "code", "curveType", "date"]

lusid/models/equity_model_options.py

@@ -26,7 +26,7 @@ class EquityModelOptions(ModelOptions):
     """
     Model options for equity related pricing.  # noqa: E501
     """
-    equity_forward_projection_type:  StrictStr = Field(...,alias="equityForwardProjectionType", description="Determines how forward equity prices should be projected.              Supported string (enumeration) values are: [FlatForwardCurveFromSpot, EquityCurveByPrices, ForwardProjectedFromRatesCurve].") 
+    equity_forward_projection_type:  StrictStr = Field(...,alias="equityForwardProjectionType", description="Determines how forward equity prices should be projected.                Supported string (enumeration) values are: [FlatForwardCurveFromSpot, EquityCurveByPrices, ForwardProjectedFromRatesCurve].") 
     model_options_type:  StrictStr = Field(...,alias="modelOptionsType", description="The available values are: Invalid, OpaqueModelOptions, EmptyModelOptions, IndexModelOptions, FxForwardModelOptions, FundingLegModelOptions, EquityModelOptions, CdsModelOptions") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["modelOptionsType", "equityForwardProjectionType"]

lusid/models/equity_option.py

@@ -31,19 +31,19 @@ class EquityOption(LusidInstrument):
     start_date: datetime = Field(..., alias="startDate", description="The start date of the instrument. This is normally synonymous with the trade-date.")
     option_maturity_date: datetime = Field(..., alias="optionMaturityDate", description="The maturity date of the option.")
     option_settlement_date: Optional[datetime] = Field(None, alias="optionSettlementDate", description="The settlement date of the option.")
-    delivery_type:  StrictStr = Field(...,alias="deliveryType", description="Is the option cash settled or physical delivery of option  Supported string (enumeration) values are: [Cash, Physical].") 
-    option_type:  StrictStr = Field(...,alias="optionType", description="Type of optionality for the option  Supported string (enumeration) values are: [Call, Put].") 
+    delivery_type:  StrictStr = Field(...,alias="deliveryType", description="Is the option cash settled or physical delivery of option    Supported string (enumeration) values are: [Cash, Physical].") 
+    option_type:  StrictStr = Field(...,alias="optionType", description="Type of optionality for the option    Supported string (enumeration) values are: [Call, Put].") 
     strike: Union[StrictFloat, StrictInt] = Field(..., description="The strike of the option.")
     dom_ccy:  StrictStr = Field(...,alias="domCcy", description="The domestic currency of the instrument.") 
-    underlying_identifier:  Optional[StrictStr] = Field(None,alias="underlyingIdentifier", description="The market identifier type of the underlying code, e.g RIC.  Supported string (enumeration) values are: [LusidInstrumentId, Isin, Sedol, Cusip, ClientInternal, Figi, RIC, QuotePermId, REDCode, BBGId, ICECode]. Optional field, should be used in combination with the Code field. Not compatible with the Underlying field.") 
-    code:  Optional[StrictStr] = Field(None,alias="code", description="The identifying code for the equity underlying, e.g. 'IBM.N'. Optional field, should be used in combination with the UnderlyingIdentifier field. Not compatible with the Underlying field.") 
-    equity_option_type:  Optional[StrictStr] = Field(None,alias="equityOptionType", description="Equity option types. E.g. Vanilla (default), RightsIssue, Warrant.  Supported string (enumeration) values are: [Vanilla, RightsIssue, Warrant].") 
+    underlying_identifier:  Optional[StrictStr] = Field(None,alias="underlyingIdentifier", description="The market identifier type of the underlying code, e.g RIC.    Supported string (enumeration) values are: [LusidInstrumentId, Isin, Sedol, Cusip, ClientInternal, Figi, RIC, QuotePermId, REDCode, BBGId, ICECode].  Optional field, should be used in combination with the Code field.  Not compatible with the Underlying field.") 
+    code:  Optional[StrictStr] = Field(None,alias="code", description="The identifying code for the equity underlying, e.g. 'IBM.N'.  Optional field, should be used in combination with the UnderlyingIdentifier field.  Not compatible with the Underlying field.") 
+    equity_option_type:  Optional[StrictStr] = Field(None,alias="equityOptionType", description="Equity option types. E.g. Vanilla (default), RightsIssue, Warrant.    Supported string (enumeration) values are: [Vanilla, RightsIssue, Warrant].") 
     number_of_shares: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="numberOfShares", description="The amount of shares to exchange if the option is exercised.")
     premium: Optional[Premium] = None
-    exercise_type:  Optional[StrictStr] = Field(None,alias="exerciseType", description="Type of optionality that is present; European, American.  Supported string (enumeration) values are: [European, American].") 
+    exercise_type:  Optional[StrictStr] = Field(None,alias="exerciseType", description="Type of optionality that is present; European, American.    Supported string (enumeration) values are: [European, American].") 
     underlying: Optional[LusidInstrument] = None
     delivery_days: Optional[StrictInt] = Field(None, alias="deliveryDays", description="Number of business days between exercise date and settlement of the option payoff or underlying.")
-    business_day_convention:  Optional[StrictStr] = Field(None,alias="businessDayConvention", description="Business day convention for option exercise date to settlement date calculation. Supported string (enumeration) values are: [NoAdjustment, Previous, P, Following, F, ModifiedPrevious, MP, ModifiedFollowing, MF, HalfMonthModifiedFollowing, Nearest].") 
+    business_day_convention:  Optional[StrictStr] = Field(None,alias="businessDayConvention", description="Business day convention for option exercise date to settlement date calculation.  Supported string (enumeration) values are: [NoAdjustment, Previous, P, Following, F, ModifiedPrevious, MP, ModifiedFollowing, MF, HalfMonthModifiedFollowing, Nearest].") 
     settlement_calendars: Optional[conlist(StrictStr)] = Field(None, alias="settlementCalendars", description="Holiday calendars for option exercise date to settlement date calculation.")
     time_zone_conventions: Optional[TimeZoneConventions] = Field(None, alias="timeZoneConventions")
     instrument_type:  StrictStr = Field(...,alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg, FundShareClass, FlexibleLoan, UnsettledCash, Cash, MasteredInstrument, LoanFacility, FlexibleDeposit, FlexibleRepo") 

lusid/models/equity_swap.py

@@ -28,20 +28,20 @@ from lusid.models.time_zone_conventions import TimeZoneConventions
 
 class EquitySwap(LusidInstrument):
     """
-    LUSID representation of an Equity Swap.              This instrument has multiple legs, to see how legs are used in LUSID see [knowledge base article KA-02252](https://support.lusid.com/knowledgebase/article/KA-02252).              | Leg Index | Leg Identifier | Description | | --------- | -------------- | ----------- | | 1 | EquityLeg | Cash flows relating to the performance of the underlying equity. | | 2 | FundingLeg | The funding leg of the swap. | | 3 | EquityDividendLeg | Cash flows relating to dividend payments on the underlying equity (optional). | | 4 | AdditionalPayments | Cash flows relating to any additional payments (optional). |  # noqa: E501
+    LUSID representation of an Equity Swap.                This instrument has multiple legs, to see how legs are used in LUSID see [knowledge base article KA-02252](https://support.lusid.com/knowledgebase/article/KA-02252).                | Leg Index | Leg Identifier | Description |  | --------- | -------------- | ----------- |  | 1 | EquityLeg | Cash flows relating to the performance of the underlying equity. |  | 2 | FundingLeg | The funding leg of the swap. |  | 3 | EquityDividendLeg | Cash flows relating to dividend payments on the underlying equity (optional). |  | 4 | AdditionalPayments | Cash flows relating to any additional payments (optional). |  # noqa: E501
     """
     start_date: datetime = Field(..., alias="startDate", description="The start date of the EquitySwap.")
-    maturity_date: datetime = Field(..., alias="maturityDate", description="The final maturity date of the instrument. This means the last date on which the instruments makes a payment of any amount. For the avoidance of doubt, that is not necessarily prior to its last sensitivity date for the purposes of risk; e.g. instruments such as Constant Maturity Swaps (CMS) often have sensitivities to rates that may well be observed or set prior to the maturity date, but refer to a termination date beyond it.")
+    maturity_date: datetime = Field(..., alias="maturityDate", description="The final maturity date of the instrument. This means the last date on which the instruments makes a payment of any amount.  For the avoidance of doubt, that is not necessarily prior to its last sensitivity date for the purposes of risk; e.g. instruments such as  Constant Maturity Swaps (CMS) often have sensitivities to rates that may well be observed or set prior to the maturity date, but refer to a termination date beyond it.")
     code:  StrictStr = Field(...,alias="code", description="The code of the underlying.") 
     equity_flow_conventions: FlowConventions = Field(..., alias="equityFlowConventions")
     funding_leg: InstrumentLeg = Field(..., alias="fundingLeg")
     include_dividends: StrictBool = Field(..., alias="includeDividends", description="Dividend inclusion flag, if true dividends are included in the equity leg (total return).")
     initial_price: Union[StrictFloat, StrictInt] = Field(..., alias="initialPrice", description="The initial equity price of the Equity Swap.")
-    notional_reset: StrictBool = Field(..., alias="notionalReset", description="Notional reset flag, if true the notional of the funding leg is reset at the start of every coupon to match the value of the equity leg (equity price at start of coupon times quantity).")
+    notional_reset: StrictBool = Field(..., alias="notionalReset", description="Notional reset flag, if true the notional of the funding leg is reset at the start of every  coupon to match the value of the equity leg (equity price at start of coupon times quantity).")
     quantity: Union[StrictFloat, StrictInt] = Field(..., description="The quantity or number of shares in the Equity Swap.")
-    underlying_identifier:  StrictStr = Field(...,alias="underlyingIdentifier", description="External market codes and identifiers for the EquitySwap, e.g. RIC.  Supported string (enumeration) values are: [LusidInstrumentId, Isin, Sedol, Cusip, ClientInternal, Figi, RIC, QuotePermId, REDCode, BBGId, ICECode].") 
-    equity_swap_dividend_payment_timing:  Optional[StrictStr] = Field(None,alias="equitySwapDividendPaymentTiming", description="Determines how the payment of dividends is handled for the equity swap. Defaults to paying at the next Equity coupon date.              Supported string (enumeration) values are: [PayAtNextEquityCouponDate, PayAtMaturityOfSwap, PayAtNextFundingLegCouponDate, PayAtPaymentDateOfDividendEvent].") 
-    additional_payments: Optional[conlist(AdditionalPayment)] = Field(None, alias="additionalPayments", description="Optional additional payments at a given date e.g. to level off an uneven equity swap. The dates must be distinct and either all payments are Pay or all payments are Receive.")
+    underlying_identifier:  StrictStr = Field(...,alias="underlyingIdentifier", description="External market codes and identifiers for the EquitySwap, e.g. RIC.    Supported string (enumeration) values are: [LusidInstrumentId, Isin, Sedol, Cusip, ClientInternal, Figi, RIC, QuotePermId, REDCode, BBGId, ICECode].") 
+    equity_swap_dividend_payment_timing:  Optional[StrictStr] = Field(None,alias="equitySwapDividendPaymentTiming", description="Determines how the payment of dividends is handled for the equity swap.  Defaults to paying at the next Equity coupon date.                Supported string (enumeration) values are: [PayAtNextEquityCouponDate, PayAtMaturityOfSwap, PayAtNextFundingLegCouponDate, PayAtPaymentDateOfDividendEvent].") 
+    additional_payments: Optional[conlist(AdditionalPayment)] = Field(None, alias="additionalPayments", description="Optional additional payments at a given date e.g. to level off an uneven equity swap.  The dates must be distinct and either all payments are Pay or all payments are Receive.")
     time_zone_conventions: Optional[TimeZoneConventions] = Field(None, alias="timeZoneConventions")
     instrument_type:  StrictStr = Field(...,alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg, FundShareClass, FlexibleLoan, UnsettledCash, Cash, MasteredInstrument, LoanFacility, FlexibleDeposit, FlexibleRepo") 
     additional_properties: Dict[str, Any] = {}

lusid/models/equity_vol_dependency.py

@@ -24,12 +24,12 @@ from lusid.models.economic_dependency import EconomicDependency
 
 class EquityVolDependency(EconomicDependency):
     """
-    Economic dependency required to price Equity derivative products that contain optionality. Equity Vol surface is a grid of implied volatilities for an array of strikes and tenors, derived from vanilla option prices in the market.  # noqa: E501
+    Economic dependency required to price Equity derivative products that contain optionality.  Equity Vol surface is a grid of implied volatilities for an array of strikes and tenors,  derived from vanilla option prices in the market.  # noqa: E501
     """
     code:  StrictStr = Field(...,alias="code", description="The code identifying the corresponding equity, e.g. US0378331005 if the MarketIdentifier was set to ISIN") 
     domestic_currency:  StrictStr = Field(...,alias="domesticCurrency", description="The domestic currency of the instrument declaring this dependency.") 
     vol_type:  StrictStr = Field(...,alias="volType", description="Volatility type e.g. \"LN\" and \"N\" for log-normal and normal volatility.") 
-    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for. Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
+    var_date: datetime = Field(..., alias="date", description="The effectiveDate of the entity that this is a dependency for.  Unless there is an obvious date this should be, like for a historic reset, then this is the valuation date.")
     dependency_type:  StrictStr = Field(...,alias="dependencyType", description="The available values are: OpaqueDependency, CashDependency, DiscountingDependency, EquityCurveDependency, EquityVolDependency, FxDependency, FxForwardsDependency, FxVolDependency, IndexProjectionDependency, IrVolDependency, QuoteDependency, Vendor, CalendarDependency, InflationFixingDependency") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["dependencyType", "code", "domesticCurrency", "volType", "date"]

lusid/models/event_date_range.py

@@ -23,7 +23,7 @@ from pydantic.v1 import StrictStr, Field, BaseModel
 
 class EventDateRange(BaseModel):
     """
-    A standard representation of the effective date range for the event, used for display, filtering and windowing use cases. The start and end values for the eventDateRange are mapped from the particular dates contained within the specific InstrumentEvent schema.  Note that the start and end values may be identical for some types of events.  # noqa: E501
+    A standard representation of the effective date range for the event, used for display, filtering and windowing use cases.  The start and end values for the eventDateRange are mapped from the particular dates contained within the specific  InstrumentEvent schema.  Note that the start and end values may be identical for some types of events.  # noqa: E501
     """
     start: Optional[datetime] = None
     end: Optional[datetime] = None

lusid/models/ex_dividend_configuration.py

@@ -25,10 +25,10 @@ class ExDividendConfiguration(BaseModel):
     """
     Configure the ex-dividend periods for the instrument.  # noqa: E501
     """
-    use_business_days: Optional[StrictBool] = Field(None, alias="useBusinessDays", description="Is the ex-dividend period counted in business days or calendar days. Defaults to false if not set.")
-    ex_dividend_days: StrictInt = Field(..., alias="exDividendDays", description="Number of days in the ex-dividend period. If the settlement date falls in the ex-dividend period then the coupon paid is zero and the accrued interest is negative. If set, this must be a non-negative number. If not set, or set to 0, than there is no ex-dividend period.")
+    use_business_days: Optional[StrictBool] = Field(None, alias="useBusinessDays", description="Is the ex-dividend period counted in business days or calendar days.  Defaults to false if not set.")
+    ex_dividend_days: StrictInt = Field(..., alias="exDividendDays", description="Number of days in the ex-dividend period.  If the settlement date falls in the ex-dividend period then the coupon paid is zero and the accrued interest is negative.  If set, this must be a non-negative number.  If not set, or set to 0, than there is no ex-dividend period.")
     return_negative_accrued: Optional[StrictBool] = Field(None, alias="returnNegativeAccrued", description="Does the accrued interest go negative in the ex-dividend period, or does it go to zero.")
-    apply_thirty360_pay_delay: Optional[StrictBool] = Field(None, alias="applyThirty360PayDelay", description="Set this flag to true if the ex-dividend days represent a pay delay from the accrual end date in calendar days under the 30/360 day count convention. The typical use case for this flag are Mortgage Backed Securities with pay delay between 1 and 60 days, such as FreddieMac and FannieMae. If this flag is set, the useBusinessDays setting will be ignored. Defaults to false if not provided.")
+    apply_thirty360_pay_delay: Optional[StrictBool] = Field(None, alias="applyThirty360PayDelay", description="Set this flag to true if the ex-dividend days represent a pay delay from the accrual end date in calendar  days under the 30/360 day count convention. The typical use case for this flag are Mortgage Backed Securities  with pay delay between 1 and 60 days, such as FreddieMac and FannieMae. If this flag is set, the useBusinessDays  setting will be ignored.  Defaults to false if not provided.")
     __properties = ["useBusinessDays", "exDividendDays", "returnNegativeAccrued", "applyThirty360PayDelay"]
 
     class Config:

lusid/models/exchange_traded_option.py

@@ -27,7 +27,7 @@ from lusid.models.trading_conventions import TradingConventions
 
 class ExchangeTradedOption(LusidInstrument):
     """
-    LUSID representation of an Exchange Traded Option. Including, but not limited to, Equity Options, Bond Options, Index Options, Future Options, and Interest Rate Options.  # noqa: E501
+    LUSID representation of an Exchange Traded Option.  Including, but not limited to, Equity Options, Bond Options, Index Options, Future Options, and Interest Rate Options.  # noqa: E501
     """
     start_date: datetime = Field(..., alias="startDate", description="The start date of the instrument. This is normally synonymous with the trade-date.")
     contract_details: ExchangeTradedOptionContractDetails = Field(..., alias="contractDetails")

lusid/models/exchange_traded_option_contract_details.py

@@ -24,23 +24,23 @@ from lusid.models.lusid_instrument import LusidInstrument
 
 class ExchangeTradedOptionContractDetails(BaseModel):
     """
-    Most, if not all, information about contracts is standardised. See, e.g. https://www.cmegroup.com/ for common codes and similar data. This appears to be in common use by well known market information providers, e.g. Bloomberg and Refinitiv. There is a lot of overlap with this and FuturesContractDetails but as that is an established DTO we must duplicate a number of fields here  # noqa: E501
+    Most, if not all, information about contracts is standardised. See, e.g. https://www.cmegroup.com/ for  common codes and similar data. This appears to be in common use by well known market information providers, e.g. Bloomberg and Refinitiv.  There is a lot of overlap with this and FuturesContractDetails but as that is an established DTO we must duplicate a number of fields here  # noqa: E501
     """
     dom_ccy:  StrictStr = Field(...,alias="domCcy", description="Currency in which the contract is paid.") 
     strike: Union[StrictFloat, StrictInt] = Field(..., description="The option strike, this can be negative for some options.")
     contract_size: Union[StrictFloat, StrictInt] = Field(..., alias="contractSize", description="Size of a single contract. By default this should be set to 1000 if otherwise unknown and is defaulted to such.")
     country:  StrictStr = Field(...,alias="country", description="Country (code) for the exchange.") 
-    delivery_type:  StrictStr = Field(...,alias="deliveryType", description="The delivery type, cash or physical. An option on a future is physically settled if upon exercising the holder receives a future.  Supported string (enumeration) values are: [Cash, Physical].") 
+    delivery_type:  StrictStr = Field(...,alias="deliveryType", description="The delivery type, cash or physical. An option on a future is physically settled if upon exercising the  holder receives a future.    Supported string (enumeration) values are: [Cash, Physical].") 
     description:  StrictStr = Field(...,alias="description", description="Description of contract") 
     exchange_code:  StrictStr = Field(...,alias="exchangeCode", description="Exchange code for contract. This can be any string to uniquely identify the exchange (e.g. Exchange Name, MIC, BBG code).") 
     exercise_date: datetime = Field(..., alias="exerciseDate", description="The last exercise date of the option.")
-    exercise_type:  StrictStr = Field(...,alias="exerciseType", description="The exercise type, European, American or Bermudan.  Supported string (enumeration) values are: [European, Bermudan, American].") 
+    exercise_type:  StrictStr = Field(...,alias="exerciseType", description="The exercise type, European, American or Bermudan.    Supported string (enumeration) values are: [European, Bermudan, American].") 
     option_code:  StrictStr = Field(...,alias="optionCode", description="Option Contract Code, typically one or two letters, e.g. OG => Option on Gold.") 
-    option_type:  StrictStr = Field(...,alias="optionType", description="The option type, Call or Put.  Supported string (enumeration) values are: [Call, Put].") 
+    option_type:  StrictStr = Field(...,alias="optionType", description="The option type, Call or Put.    Supported string (enumeration) values are: [Call, Put].") 
     underlying: LusidInstrument = Field(...)
     underlying_code:  StrictStr = Field(...,alias="underlyingCode", description="Code of the underlying, for an option on futures this should be the futures code.") 
     delivery_days: Optional[StrictInt] = Field(None, alias="deliveryDays", description="Number of business days between exercise date and settlement of the option payoff or underlying.")
-    business_day_convention:  Optional[StrictStr] = Field(None,alias="businessDayConvention", description="The adjustment type to apply to dates that fall upon a non-business day, e.g. modified following or following. Supported string (enumeration) values are: [NoAdjustment, Previous, P, Following, F, ModifiedPrevious, MP, ModifiedFollowing, MF, HalfMonthModifiedFollowing, Nearest].") 
+    business_day_convention:  Optional[StrictStr] = Field(None,alias="businessDayConvention", description="The adjustment type to apply to dates that fall upon a non-business day, e.g. modified following or following.  Supported string (enumeration) values are: [NoAdjustment, Previous, P, Following, F, ModifiedPrevious, MP, ModifiedFollowing, MF, HalfMonthModifiedFollowing, Nearest].") 
     settlement_calendars: Optional[conlist(StrictStr)] = Field(None, alias="settlementCalendars", description="An array of strings denoting calendars used in calculating the option settlement date.")
     __properties = ["domCcy", "strike", "contractSize", "country", "deliveryType", "description", "exchangeCode", "exerciseDate", "exerciseType", "optionCode", "optionType", "underlying", "underlyingCode", "deliveryDays", "businessDayConvention", "settlementCalendars"]
 

lusid/models/execution.py

@@ -29,7 +29,7 @@ from lusid.models.version import Version
 
 class Execution(BaseModel):
     """
-    The record of a number of executions against a single Placement (directly analogous to a partial or full fill against a street order).  # noqa: E501
+    The record of a number of executions against a single Placement (directly analogous to  a partial or full fill against a street order).  # noqa: E501
     """
     id: ResourceId = Field(...)
     placement_id: ResourceId = Field(..., alias="placementId")

lusid/models/exercise_event.py

@@ -25,7 +25,7 @@ from lusid.models.lusid_instrument import LusidInstrument
 
 class ExerciseEvent(InstrumentEvent):
     """
-    Definition of an exercise event. This is an event that occurs on transformation of an instrument owing to exercise. e.g. an option of some type into its underlying.  # noqa: E501
+    Definition of an exercise event.  This is an event that occurs on transformation of an instrument owing to exercise. e.g. an option of  some type into its underlying.  # noqa: E501
     """
     instrument: LusidInstrument = Field(...)
     anchor_date: datetime = Field(..., alias="anchorDate", description="The date the exercise window starts, or point it takes effect on.")

lusid/models/exotic_instrument.py

@@ -28,7 +28,7 @@ class ExoticInstrument(LusidInstrument):
     LUSID representation of a generic OTC Exotic Instrument that is not fully defined within other LUSID models.  # noqa: E501
     """
     instrument_format: InstrumentDefinitionFormat = Field(..., alias="instrumentFormat")
-    content:  StrictStr = Field(...,alias="content", description="The original document received into the system. This format could potentially be anything though is most likely to be either Json or Xml. In the case where no other interface is supported it is possible to fall back onto this. For example, a trade from an external client system. This may be recognized internally by Lusid or simply passed through to another vendor system.") 
+    content:  StrictStr = Field(...,alias="content", description="The original document received into the system. This format could potentially be anything though is most likely to be either Json or Xml. In the case where no other  interface is supported it is possible to fall back onto this.  For example, a trade from an external client system. This may be recognized internally by Lusid or simply passed through to another vendor system.") 
     instrument_type:  StrictStr = Field(...,alias="instrumentType", description="The available values are: QuotedSecurity, InterestRateSwap, FxForward, Future, ExoticInstrument, FxOption, CreditDefaultSwap, InterestRateSwaption, Bond, EquityOption, FixedLeg, FloatingLeg, BespokeCashFlowsLeg, Unknown, TermDeposit, ContractForDifference, EquitySwap, CashPerpetual, CapFloor, CashSettled, CdsIndex, Basket, FundingLeg, FxSwap, ForwardRateAgreement, SimpleInstrument, Repo, Equity, ExchangeTradedOption, ReferenceInstrument, ComplexBond, InflationLinkedBond, InflationSwap, SimpleCashFlowLoan, TotalReturnSwap, InflationLeg, FundShareClass, FlexibleLoan, UnsettledCash, Cash, MasteredInstrument, LoanFacility, FlexibleDeposit, FlexibleRepo") 
     additional_properties: Dict[str, Any] = {}
     __properties = ["instrumentType", "instrumentFormat", "content"]

lusid/models/expiry_event.py

@@ -24,7 +24,7 @@ from lusid.models.instrument_event import InstrumentEvent
 
 class ExpiryEvent(InstrumentEvent):
     """
-    Definition of an Expiry Event This is an event that describes the expiry of the instrument.  # noqa: E501
+    Definition of an Expiry Event  This is an event that describes the expiry of the instrument.  # noqa: E501
     """
     expiry_date: Optional[datetime] = Field(None, alias="expiryDate", description="Expiry date of the instrument")
     instrument_event_type:  StrictStr = Field(...,alias="instrumentEventType", description="The Type of Event. The available values are: TransitionEvent, InformationalEvent, OpenEvent, CloseEvent, StockSplitEvent, BondDefaultEvent, CashDividendEvent, AmortisationEvent, CashFlowEvent, ExerciseEvent, ResetEvent, TriggerEvent, RawVendorEvent, InformationalErrorEvent, BondCouponEvent, DividendReinvestmentEvent, AccumulationEvent, BondPrincipalEvent, DividendOptionEvent, MaturityEvent, FxForwardSettlementEvent, ExpiryEvent, ScripDividendEvent, StockDividendEvent, ReverseStockSplitEvent, CapitalDistributionEvent, SpinOffEvent, MergerEvent, FutureExpiryEvent, SwapCashFlowEvent, SwapPrincipalEvent, CreditPremiumCashFlowEvent, CdsCreditEvent, CdxCreditEvent, MbsCouponEvent, MbsPrincipalEvent, BonusIssueEvent, MbsPrincipalWriteOffEvent, MbsInterestDeferralEvent, MbsInterestShortfallEvent, TenderEvent, CallOnIntermediateSecuritiesEvent, IntermediateSecuritiesDistributionEvent, OptionExercisePhysicalEvent, OptionExerciseCashEvent, ProtectionPayoutCashFlowEvent, TermDepositInterestEvent, TermDepositPrincipalEvent, EarlyRedemptionEvent, FutureMarkToMarketEvent, AdjustGlobalCommitmentEvent, ContractInitialisationEvent, DrawdownEvent, LoanInterestRepaymentEvent, UpdateDepositAmountEvent, LoanPrincipalRepaymentEvent, DepositInterestPaymentEvent, DepositCloseEvent, LoanFacilityContractRolloverEvent, RepurchaseOfferEvent, RepoPartialClosureEvent, RepoCashFlowEvent, FlexibleRepoInterestPaymentEvent, FlexibleRepoCashFlowEvent, FlexibleRepoCollateralEvent, ConversionEvent, FlexibleRepoPartialClosureEvent, FlexibleRepoFullClosureEvent") 

lusid/models/fixed_leg.py

@@ -30,7 +30,7 @@ class FixedLeg(InstrumentLeg):
     LUSID representation of a Fixed Rate Leg.  # noqa: E501
     """
     start_date: datetime = Field(..., alias="startDate", description="The start date of the instrument. This is normally synonymous with the trade-date.")
-    maturity_date: datetime = Field(..., alias="maturityDate", description="The final maturity date of the instrument. This means the last date on which the instruments makes a payment of any amount. For the avoidance of doubt, that is not necessarily prior to its last sensitivity date for the purposes of risk; e.g. instruments such as Constant Maturity Swaps (CMS) often have sensitivities to rates that may well be observed or set prior to the maturity date, but refer to a termination date beyond it.")
+    maturity_date: datetime = Field(..., alias="maturityDate", description="The final maturity date of the instrument. This means the last date on which the instruments makes a payment of any amount.  For the avoidance of doubt, that is not necessarily prior to its last sensitivity date for the purposes of risk; e.g. instruments such as  Constant Maturity Swaps (CMS) often have sensitivities to rates that may well be observed or set prior to the maturity date, but refer to a termination date beyond it.")
     leg_definition: LegDefinition = Field(..., alias="legDefinition")
     notional: Union[StrictFloat, StrictInt] = Field(...)
     overrides: Optional[FixedLegAllOfOverrides] = None

lusid/models/fixed_leg_all_of_overrides.py

@@ -23,7 +23,7 @@ from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictI
 
 class FixedLegAllOfOverrides(BaseModel):
     """
-    Any overriding data for notionals, spreads or rates that would affect generation of a leg. This supports the case where an amortisation schedule is given but otherwise generation is allowed as usual.  # noqa: E501
+    Any overriding data for notionals, spreads or rates that would affect generation of a leg.  This supports the case where an amortisation schedule is given but otherwise generation is allowed as usual.  # noqa: E501
     """
     amortization: Optional[conlist(Union[StrictFloat, StrictInt])] = Field(None, alias="Amortization")
     spreads: Optional[conlist(Union[StrictFloat, StrictInt])] = Field(None, alias="Spreads")

lusid/models/fixed_schedule.py

@@ -30,14 +30,14 @@ class FixedSchedule(Schedule):
     Schedule for fixed coupon payments  # noqa: E501
     """
     start_date: datetime = Field(..., alias="startDate", description="Date from which LUSID starts generating the payment schedule.")
-    maturity_date: datetime = Field(..., alias="maturityDate", description="Last date of the payment generation schedule. May not necessarily be the maturity date of the underlying instrument (e.g. in case the instrument has multiple payment schedules).")
+    maturity_date: datetime = Field(..., alias="maturityDate", description="Last date of the payment generation schedule. May not necessarily be the maturity date  of the underlying instrument (e.g. in case the instrument has multiple payment schedules).")
     flow_conventions: Optional[FlowConventions] = Field(None, alias="flowConventions")
     coupon_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="couponRate", description="Coupon rate given as a fraction.")
     convention_name: Optional[FlowConventionName] = Field(None, alias="conventionName")
-    ex_dividend_days: Optional[StrictInt] = Field(None, alias="exDividendDays", description="Optional. Number of calendar days in the ex-dividend period. If the settlement date falls in the ex-dividend period then the coupon paid is zero and the accrued interest is negative. If set, this must be a non-negative number. If not set, or set to 0, then there is no ex-dividend period.              NOTE: This field is deprecated.  If you wish to set the ExDividendDays on a bond, please use the ExDividendConfiguration.")
+    ex_dividend_days: Optional[StrictInt] = Field(None, alias="exDividendDays", description="Optional. Number of calendar days in the ex-dividend period.  If the settlement date falls in the ex-dividend period then the coupon paid is zero and the accrued interest is negative.  If set, this must be a non-negative number.  If not set, or set to 0, then there is no ex-dividend period.                NOTE: This field is deprecated.  If you wish to set the ExDividendDays on a bond, please use the ExDividendConfiguration.")
     notional: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Scaling factor, the quantity outstanding on which the rate will be paid.")
     payment_currency:  StrictStr = Field(...,alias="paymentCurrency", description="Payment currency. This does not have to be the same as the nominal bond or observation/reset currency.") 
-    stub_type:  Optional[StrictStr] = Field(None,alias="stubType", description="When a payment schedule doesn't have regular payment intervals just because of the first and/or last coupons of the schedule, we call those irregular coupons stubs. This configuration specifies what type of stub is used when building the schedule Supported values are: None = this is a regular payment schedule with no stubs. DO NOT use it with irregular schedules or you will get incorrect and unexpected behaviour. ShortFront = this is an irregular payment schedule where only the first coupon is irregular, and covers a payment period that is shorter than the regular payment period. ShortBack = this is an irregular payment schedule where only the last coupon is irregular, and covers a payment period that is shorter than the regular payment period. LongFront = this is an irregular payment schedule where only the first coupon is irregular, and covers a payment period that is longer than the regular payment period. LongBack = this is an irregular payment schedule where only the last coupon is irregular, and covers a payment period that is longer than the regular payment period. Both = this is an irregular payment schedule where both the first and the last coupons are irregular, and the length of these periods is calculated based on the first coupon payment date that should have been explicitly set.") 
+    stub_type:  Optional[StrictStr] = Field(None,alias="stubType", description="When a payment schedule doesn't have regular payment intervals just because of the  first and/or last coupons of the schedule, we call those irregular coupons stubs.  This configuration specifies what type of stub is used when building the schedule  Supported values are:  None = this is a regular payment schedule with no stubs. DO NOT use it with irregular schedules or you will get incorrect and unexpected behaviour.  ShortFront = this is an irregular payment schedule where only the first coupon is irregular, and covers a payment period that is shorter than the regular payment period.  ShortBack = this is an irregular payment schedule where only the last coupon is irregular, and covers a payment period that is shorter than the regular payment period.  LongFront = this is an irregular payment schedule where only the first coupon is irregular, and covers a payment period that is longer than the regular payment period.  LongBack = this is an irregular payment schedule where only the last coupon is irregular, and covers a payment period that is longer than the regular payment period.  Both = this is an irregular payment schedule where both the first and the last coupons are irregular, and the length of these periods is calculated based on the first coupon payment date that should have been explicitly set.") 
     ex_dividend_configuration: Optional[ExDividendConfiguration] = Field(None, alias="exDividendConfiguration")
     schedule_type:  StrictStr = Field(...,alias="scheduleType", description="The available values are: FixedSchedule, FloatSchedule, OptionalitySchedule, StepSchedule, Exercise, FxRateSchedule, FxLinkedNotionalSchedule, BondConversionSchedule, Invalid") 
     additional_properties: Dict[str, Any] = {}