lusid-sdk 2.1.462__py3-none-any.whl → 2.1.542__py3-none-any.whl

lusid/models/fund_valuation_point_data.py

@@ -24,7 +24,6 @@ from lusid.models.fee_accrual import FeeAccrual
 from lusid.models.fund_amount import FundAmount
 from lusid.models.fund_pnl_breakdown import FundPnlBreakdown
 from lusid.models.previous_fund_valuation_point_data import PreviousFundValuationPointData
-from lusid.models.unitisation_data import UnitisationData
 
 class FundValuationPointData(BaseModel):
     """
@@ -36,10 +35,9 @@ class FundValuationPointData(BaseModel):
     gav: Union[StrictFloat, StrictInt] = Field(..., description="The Gross Asset Value of the Fund or Share Class at the Valuation Point. This is effectively a summation of all Trial balance entries linked to accounts of types 'Asset' and 'Liabilities'.")
     fees: Dict[str, FeeAccrual] = Field(..., description="Bucket of detail for any 'Fees' that have been charged in the selected period.")
     nav: Union[StrictFloat, StrictInt] = Field(..., description="The Net Asset Value of the Fund or Share Class at the Valuation Point. This represents the GAV with any fees applied in the period.")
-    unitisation: Optional[UnitisationData] = None
     miscellaneous: Optional[Dict[str, FundAmount]] = Field(None, description="Not used directly by the LUSID engines but serves as a holding area for any custom derived data points that may be useful in, for example, fee calculations).")
     previous_valuation_point_data: Optional[PreviousFundValuationPointData] = Field(None, alias="previousValuationPointData")
-    __properties = ["backOut", "dealing", "pnL", "gav", "fees", "nav", "unitisation", "miscellaneous", "previousValuationPointData"]
+    __properties = ["backOut", "dealing", "pnL", "gav", "fees", "nav", "miscellaneous", "previousValuationPointData"]
 
     class Config:
         """Pydantic configuration"""
@@ -89,9 +87,6 @@ class FundValuationPointData(BaseModel):
                 if self.fees[_key]:
                     _field_dict[_key] = self.fees[_key].to_dict()
             _dict['fees'] = _field_dict
-        # override the default output from pydantic by calling `to_dict()` of unitisation
-        if self.unitisation:
-            _dict['unitisation'] = self.unitisation.to_dict()
         # override the default output from pydantic by calling `to_dict()` of each value in miscellaneous (dict)
         _field_dict = {}
         if self.miscellaneous:
@@ -140,7 +135,6 @@ class FundValuationPointData(BaseModel):
             if obj.get("fees") is not None
             else None,
             "nav": obj.get("nav"),
-            "unitisation": UnitisationData.from_dict(obj.get("unitisation")) if obj.get("unitisation") is not None else None,
             "miscellaneous": dict(
                 (_k, FundAmount.from_dict(_v))
                 for _k, _v in obj.get("miscellaneous").items()

lusid/models/future_expiry_event.py

@@ -29,15 +29,15 @@ class FutureExpiryEvent(InstrumentEvent):
     expiry_date: datetime = Field(..., alias="expiryDate", description="Expiry date of the Future instrument.")
     settlement_currency: StrictStr = Field(..., alias="settlementCurrency", description="Settlement currency of the Future instrument.")
     notional_amount_per_unit: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="notionalAmountPerUnit", description="The notional amount of each unit in the Future 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")
+    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")
     additional_properties: Dict[str, Any] = {}
     __properties = ["instrumentEventType", "expiryDate", "settlementCurrency", "notionalAmountPerUnit"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('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'):
-            raise ValueError("must be one of enum values ('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')")
+        if value not in ('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'):
+            raise ValueError("must be one of enum values ('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')")
         return value
 
     class Config:

lusid/models/fx_forward_settlement_event.py

@@ -38,15 +38,15 @@ class FxForwardSettlementEvent(InstrumentEvent):
     domestic_to_foreign_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="domesticToForeignRate", description="Domestic currency to foreign currency FX rate.  Not required, only used to override quotes.")
     domestic_to_settlement_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="domesticToSettlementRate", description="Domestic currency to settlement currency FX rate  Not required, only used to override quotes.")
     foreign_to_settlement_rate: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="foreignToSettlementRate", description="Foreign currency to settlement currency FX rate  Not required, only used to override quotes.")
-    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")
+    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")
     additional_properties: Dict[str, Any] = {}
     __properties = ["instrumentEventType", "maturityDate", "domAmountPerUnit", "domCcy", "fgnAmountPerUnit", "fgnCcy", "isNdf", "fixingDate", "settlementCcy", "cashFlowPerUnit", "domesticToForeignRate", "domesticToSettlementRate", "foreignToSettlementRate"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('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'):
-            raise ValueError("must be one of enum values ('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')")
+        if value not in ('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'):
+            raise ValueError("must be one of enum values ('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')")
         return value
 
     class Config:

lusid/models/group_reconciliation_aggregate_attribute_values.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.comparison_attribute_value_pair import ComparisonAttributeValuePair
+
+class GroupReconciliationAggregateAttributeValues(BaseModel):
+    """
+    GroupReconciliationAggregateAttributeValues
+    """
+    left_aggregate_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="leftAggregateAttributes", description="Aggregate attribute names and values for the left hand entity being reconciled.")
+    right_aggregate_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="rightAggregateAttributes", description="Aggregate attribute names and values for the right hand entity being reconciled.")
+    __properties = ["leftAggregateAttributes", "rightAggregateAttributes"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationAggregateAttributeValues:
+        """Create an instance of GroupReconciliationAggregateAttributeValues from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in left_aggregate_attributes (list)
+        _items = []
+        if self.left_aggregate_attributes:
+            for _item in self.left_aggregate_attributes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['leftAggregateAttributes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in right_aggregate_attributes (list)
+        _items = []
+        if self.right_aggregate_attributes:
+            for _item in self.right_aggregate_attributes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['rightAggregateAttributes'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationAggregateAttributeValues:
+        """Create an instance of GroupReconciliationAggregateAttributeValues from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationAggregateAttributeValues.parse_obj(obj)
+
+        _obj = GroupReconciliationAggregateAttributeValues.parse_obj({
+            "left_aggregate_attributes": [ComparisonAttributeValuePair.from_dict(_item) for _item in obj.get("leftAggregateAttributes")] if obj.get("leftAggregateAttributes") is not None else None,
+            "right_aggregate_attributes": [ComparisonAttributeValuePair.from_dict(_item) for _item in obj.get("rightAggregateAttributes")] if obj.get("rightAggregateAttributes") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_comparison_result.py

@@ -0,0 +1,148 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+from pydantic.v1 import BaseModel, Field, StrictStr, conlist, constr
+from lusid.models.group_reconciliation_aggregate_attribute_values import GroupReconciliationAggregateAttributeValues
+from lusid.models.group_reconciliation_core_attribute_values import GroupReconciliationCoreAttributeValues
+from lusid.models.group_reconciliation_dates import GroupReconciliationDates
+from lusid.models.group_reconciliation_instance_id import GroupReconciliationInstanceId
+from lusid.models.group_reconciliation_user_review import GroupReconciliationUserReview
+from lusid.models.link import Link
+from lusid.models.resource_id import ResourceId
+from lusid.models.version import Version
+
+class GroupReconciliationComparisonResult(BaseModel):
+    """
+    GroupReconciliationComparisonResult
+    """
+    id: ResourceId = Field(...)
+    reconciliation_type: constr(strict=True, min_length=1) = Field(..., alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"")
+    group_reconciliation_definition_id: ResourceId = Field(..., alias="groupReconciliationDefinitionId")
+    instance_id: GroupReconciliationInstanceId = Field(..., alias="instanceId")
+    comparison_result_id: constr(strict=True, min_length=1) = Field(..., alias="comparisonResultId", description="Comparison result identifier, encoded value for core attribute results, aggregate attribute results, reconciliation type and run instanceId.")
+    reconciliation_run_as_at: datetime = Field(..., alias="reconciliationRunAsAt", description="The timestamp when the run occurred.")
+    result_type: constr(strict=True, min_length=1) = Field(..., alias="resultType", description="Reconciliation run general result. \"Break\" | \"Match\" | \"PartialMatch\" | \"NotFound")
+    result_status: constr(strict=True, min_length=1) = Field(..., alias="resultStatus", description="Indicates how a particular result evolves from one run to the next. \"New\" | \"Confirmed\" | \"Changed\"")
+    review_status: constr(strict=True, min_length=1) = Field(..., alias="reviewStatus", description="Status of whether user has provided any input (comments, manual matches, break codes). \"Pending\" | \"Reviewed\" | \"Matched\" | \"Invalid\"")
+    dates_reconciled: GroupReconciliationDates = Field(..., alias="datesReconciled")
+    core_attributes: GroupReconciliationCoreAttributeValues = Field(..., alias="coreAttributes")
+    aggregate_attributes: GroupReconciliationAggregateAttributeValues = Field(..., alias="aggregateAttributes")
+    user_review: Optional[GroupReconciliationUserReview] = Field(None, alias="userReview")
+    href: Optional[StrictStr] = Field(None, description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.")
+    version: Optional[Version] = None
+    links: Optional[conlist(Link)] = None
+    __properties = ["id", "reconciliationType", "groupReconciliationDefinitionId", "instanceId", "comparisonResultId", "reconciliationRunAsAt", "resultType", "resultStatus", "reviewStatus", "datesReconciled", "coreAttributes", "aggregateAttributes", "userReview", "href", "version", "links"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationComparisonResult:
+        """Create an instance of GroupReconciliationComparisonResult from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of id
+        if self.id:
+            _dict['id'] = self.id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of group_reconciliation_definition_id
+        if self.group_reconciliation_definition_id:
+            _dict['groupReconciliationDefinitionId'] = self.group_reconciliation_definition_id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of instance_id
+        if self.instance_id:
+            _dict['instanceId'] = self.instance_id.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of dates_reconciled
+        if self.dates_reconciled:
+            _dict['datesReconciled'] = self.dates_reconciled.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of core_attributes
+        if self.core_attributes:
+            _dict['coreAttributes'] = self.core_attributes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of aggregate_attributes
+        if self.aggregate_attributes:
+            _dict['aggregateAttributes'] = self.aggregate_attributes.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of user_review
+        if self.user_review:
+            _dict['userReview'] = self.user_review.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of each item in links (list)
+        _items = []
+        if self.links:
+            for _item in self.links:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['links'] = _items
+        # set to None if href (nullable) is None
+        # and __fields_set__ contains the field
+        if self.href is None and "href" in self.__fields_set__:
+            _dict['href'] = None
+
+        # set to None if links (nullable) is None
+        # and __fields_set__ contains the field
+        if self.links is None and "links" in self.__fields_set__:
+            _dict['links'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationComparisonResult:
+        """Create an instance of GroupReconciliationComparisonResult from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationComparisonResult.parse_obj(obj)
+
+        _obj = GroupReconciliationComparisonResult.parse_obj({
+            "id": ResourceId.from_dict(obj.get("id")) if obj.get("id") is not None else None,
+            "reconciliation_type": obj.get("reconciliationType"),
+            "group_reconciliation_definition_id": ResourceId.from_dict(obj.get("groupReconciliationDefinitionId")) if obj.get("groupReconciliationDefinitionId") is not None else None,
+            "instance_id": GroupReconciliationInstanceId.from_dict(obj.get("instanceId")) if obj.get("instanceId") is not None else None,
+            "comparison_result_id": obj.get("comparisonResultId"),
+            "reconciliation_run_as_at": obj.get("reconciliationRunAsAt"),
+            "result_type": obj.get("resultType"),
+            "result_status": obj.get("resultStatus"),
+            "review_status": obj.get("reviewStatus"),
+            "dates_reconciled": GroupReconciliationDates.from_dict(obj.get("datesReconciled")) if obj.get("datesReconciled") is not None else None,
+            "core_attributes": GroupReconciliationCoreAttributeValues.from_dict(obj.get("coreAttributes")) if obj.get("coreAttributes") is not None else None,
+            "aggregate_attributes": GroupReconciliationAggregateAttributeValues.from_dict(obj.get("aggregateAttributes")) if obj.get("aggregateAttributes") is not None else None,
+            "user_review": GroupReconciliationUserReview.from_dict(obj.get("userReview")) if obj.get("userReview") is not None else None,
+            "href": obj.get("href"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_core_attribute_values.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, List
+from pydantic.v1 import BaseModel, Field, conlist
+from lusid.models.comparison_attribute_value_pair import ComparisonAttributeValuePair
+
+class GroupReconciliationCoreAttributeValues(BaseModel):
+    """
+    GroupReconciliationCoreAttributeValues
+    """
+    left_core_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="leftCoreAttributes", description="Core attribute names and values for the left hand entity being reconciled.")
+    right_core_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="rightCoreAttributes", description="Core attribute names and values for the right hand entity being reconciled.")
+    __properties = ["leftCoreAttributes", "rightCoreAttributes"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationCoreAttributeValues:
+        """Create an instance of GroupReconciliationCoreAttributeValues from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of each item in left_core_attributes (list)
+        _items = []
+        if self.left_core_attributes:
+            for _item in self.left_core_attributes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['leftCoreAttributes'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in right_core_attributes (list)
+        _items = []
+        if self.right_core_attributes:
+            for _item in self.right_core_attributes:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['rightCoreAttributes'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationCoreAttributeValues:
+        """Create an instance of GroupReconciliationCoreAttributeValues from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationCoreAttributeValues.parse_obj(obj)
+
+        _obj = GroupReconciliationCoreAttributeValues.parse_obj({
+            "left_core_attributes": [ComparisonAttributeValuePair.from_dict(_item) for _item in obj.get("leftCoreAttributes")] if obj.get("leftCoreAttributes") is not None else None,
+            "right_core_attributes": [ComparisonAttributeValuePair.from_dict(_item) for _item in obj.get("rightCoreAttributes")] if obj.get("rightCoreAttributes") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_date_pair.py

@@ -0,0 +1,81 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from datetime import datetime
+from typing import Any, Dict, Optional
+from pydantic.v1 import BaseModel, Field
+
+class GroupReconciliationDatePair(BaseModel):
+    """
+    GroupReconciliationDatePair
+    """
+    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective at date for the reconciliation")
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="The as at date for the reconciliation")
+    __properties = ["effectiveAt", "asAt"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationDatePair:
+        """Create an instance of GroupReconciliationDatePair from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # set to None if effective_at (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_at is None and "effective_at" in self.__fields_set__:
+            _dict['effectiveAt'] = None
+
+        # set to None if as_at (nullable) is None
+        # and __fields_set__ contains the field
+        if self.as_at is None and "as_at" in self.__fields_set__:
+            _dict['asAt'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDatePair:
+        """Create an instance of GroupReconciliationDatePair from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDatePair.parse_obj(obj)
+
+        _obj = GroupReconciliationDatePair.parse_obj({
+            "effective_at": obj.get("effectiveAt"),
+            "as_at": obj.get("asAt")
+        })
+        return _obj

lusid/models/group_reconciliation_dates.py

@@ -0,0 +1,78 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict, Optional
+from pydantic.v1 import BaseModel
+from lusid.models.group_reconciliation_date_pair import GroupReconciliationDatePair
+
+class GroupReconciliationDates(BaseModel):
+    """
+    GroupReconciliationDates
+    """
+    left: Optional[GroupReconciliationDatePair] = None
+    right: Optional[GroupReconciliationDatePair] = None
+    __properties = ["left", "right"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationDates:
+        """Create an instance of GroupReconciliationDates from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of left
+        if self.left:
+            _dict['left'] = self.left.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of right
+        if self.right:
+            _dict['right'] = self.right.to_dict()
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationDates:
+        """Create an instance of GroupReconciliationDates from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationDates.parse_obj(obj)
+
+        _obj = GroupReconciliationDates.parse_obj({
+            "left": GroupReconciliationDatePair.from_dict(obj.get("left")) if obj.get("left") is not None else None,
+            "right": GroupReconciliationDatePair.from_dict(obj.get("right")) if obj.get("right") is not None else None
+        })
+        return _obj

lusid/models/group_reconciliation_instance_id.py

@@ -0,0 +1,71 @@
+# coding: utf-8
+
+"""
+    LUSID API
+
+    FINBOURNE Technology  # noqa: E501
+
+    Contact: info@finbourne.com
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+
+from typing import Any, Dict
+from pydantic.v1 import BaseModel, Field, constr
+
+class GroupReconciliationInstanceId(BaseModel):
+    """
+    GroupReconciliationInstanceId
+    """
+    run_id_type: constr(strict=True, min_length=1) = Field(..., alias="runIdType", description="Type of the reconciliation run, manual or automatic (via the workflow). \"Manual\" | \"WorkflowServiceTaskId\"")
+    run_id_value: constr(strict=True, min_length=1) = Field(..., alias="runIdValue", description="Reconciliation run identifier: a manually-provided key or taskId.")
+    __properties = ["runIdType", "runIdValue"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> GroupReconciliationInstanceId:
+        """Create an instance of GroupReconciliationInstanceId from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self):
+        """Returns the dictionary representation of the model using alias"""
+        _dict = self.dict(by_alias=True,
+                          exclude={
+                          },
+                          exclude_none=True)
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> GroupReconciliationInstanceId:
+        """Create an instance of GroupReconciliationInstanceId from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return GroupReconciliationInstanceId.parse_obj(obj)
+
+        _obj = GroupReconciliationInstanceId.parse_obj({
+            "run_id_type": obj.get("runIdType"),
+            "run_id_value": obj.get("runIdValue")
+        })
+        return _obj