lusid-sdk 2.1.989__py3-none-any.whl → 2.1.990__py3-none-any.whl

lusid/models/__init__.py

@@ -84,6 +84,7 @@ from lusid.models.append_fx_forward_tenor_curve_data import AppendFxForwardTenor
 from lusid.models.append_fx_forward_tenor_pips_curve_data import AppendFxForwardTenorPipsCurveData
 from lusid.models.append_market_data import AppendMarketData
 from lusid.models.append_market_data_type import AppendMarketDataType
+from lusid.models.applicable_entity import ApplicableEntity
 from lusid.models.applicable_instrument_event import ApplicableInstrumentEvent
 from lusid.models.asset_class import AssetClass
 from lusid.models.asset_leg import AssetLeg
@@ -101,6 +102,7 @@ from lusid.models.batch_upsert_portfolio_access_metadata_response import BatchUp
 from lusid.models.batch_upsert_portfolio_access_metadata_response_item import BatchUpsertPortfolioAccessMetadataResponseItem
 from lusid.models.batch_upsert_portfolio_transactions_response import BatchUpsertPortfolioTransactionsResponse
 from lusid.models.batch_upsert_property_definition_properties_response import BatchUpsertPropertyDefinitionPropertiesResponse
+from lusid.models.batch_upsert_relational_datasets_response import BatchUpsertRelationalDatasetsResponse
 from lusid.models.batch_upsert_transaction_settlement_instruction_response import BatchUpsertTransactionSettlementInstructionResponse
 from lusid.models.block import Block
 from lusid.models.block_and_order_id_request import BlockAndOrderIdRequest
@@ -785,6 +787,7 @@ from lusid.models.paged_resource_list_of_property_definition import PagedResourc
 from lusid.models.paged_resource_list_of_property_definition_search_result import PagedResourceListOfPropertyDefinitionSearchResult
 from lusid.models.paged_resource_list_of_reconciliation import PagedResourceListOfReconciliation
 from lusid.models.paged_resource_list_of_reference_list_response import PagedResourceListOfReferenceListResponse
+from lusid.models.paged_resource_list_of_relational_data_point_response import PagedResourceListOfRelationalDataPointResponse
 from lusid.models.paged_resource_list_of_relational_dataset_definition import PagedResourceListOfRelationalDatasetDefinition
 from lusid.models.paged_resource_list_of_relationship_definition import PagedResourceListOfRelationshipDefinition
 from lusid.models.paged_resource_list_of_sequence_definition import PagedResourceListOfSequenceDefinition
@@ -888,6 +891,7 @@ from lusid.models.query_applicable_instrument_events_request import QueryApplica
 from lusid.models.query_bucketed_cash_flows_request import QueryBucketedCashFlowsRequest
 from lusid.models.query_cash_flows_request import QueryCashFlowsRequest
 from lusid.models.query_instrument_events_request import QueryInstrumentEventsRequest
+from lusid.models.query_relational_dataset_request import QueryRelationalDatasetRequest
 from lusid.models.query_trade_tickets_request import QueryTradeTicketsRequest
 from lusid.models.queryable_key import QueryableKey
 from lusid.models.quote import Quote
@@ -934,6 +938,9 @@ from lusid.models.reference_portfolio_weight_type import ReferencePortfolioWeigh
 from lusid.models.related_entity import RelatedEntity
 from lusid.models.relation import Relation
 from lusid.models.relation_definition import RelationDefinition
+from lusid.models.relational_data_point_field_value_response import RelationalDataPointFieldValueResponse
+from lusid.models.relational_data_point_response import RelationalDataPointResponse
+from lusid.models.relational_data_series_response import RelationalDataSeriesResponse
 from lusid.models.relational_dataset_definition import RelationalDatasetDefinition
 from lusid.models.relational_dataset_field_definition import RelationalDatasetFieldDefinition
 from lusid.models.relationship import Relationship
@@ -1265,6 +1272,8 @@ from lusid.models.upsert_reference_portfolio_constituent_properties_request impo
 from lusid.models.upsert_reference_portfolio_constituent_properties_response import UpsertReferencePortfolioConstituentPropertiesResponse
 from lusid.models.upsert_reference_portfolio_constituents_request import UpsertReferencePortfolioConstituentsRequest
 from lusid.models.upsert_reference_portfolio_constituents_response import UpsertReferencePortfolioConstituentsResponse
+from lusid.models.upsert_relational_data_point_data_series import UpsertRelationalDataPointDataSeries
+from lusid.models.upsert_relational_data_point_request import UpsertRelationalDataPointRequest
 from lusid.models.upsert_result_values_data_request import UpsertResultValuesDataRequest
 from lusid.models.upsert_returns_response import UpsertReturnsResponse
 from lusid.models.upsert_single_structured_data_response import UpsertSingleStructuredDataResponse
@@ -1391,6 +1400,7 @@ __all__ = [
     "AppendFxForwardTenorPipsCurveData",
     "AppendMarketData",
     "AppendMarketDataType",
+    "ApplicableEntity",
     "ApplicableInstrumentEvent",
     "AssetClass",
     "AssetLeg",
@@ -1408,6 +1418,7 @@ __all__ = [
     "BatchUpsertPortfolioAccessMetadataResponseItem",
     "BatchUpsertPortfolioTransactionsResponse",
     "BatchUpsertPropertyDefinitionPropertiesResponse",
+    "BatchUpsertRelationalDatasetsResponse",
     "BatchUpsertTransactionSettlementInstructionResponse",
     "Block",
     "BlockAndOrderIdRequest",
@@ -2092,6 +2103,7 @@ __all__ = [
     "PagedResourceListOfPropertyDefinitionSearchResult",
     "PagedResourceListOfReconciliation",
     "PagedResourceListOfReferenceListResponse",
+    "PagedResourceListOfRelationalDataPointResponse",
     "PagedResourceListOfRelationalDatasetDefinition",
     "PagedResourceListOfRelationshipDefinition",
     "PagedResourceListOfSequenceDefinition",
@@ -2195,6 +2207,7 @@ __all__ = [
     "QueryBucketedCashFlowsRequest",
     "QueryCashFlowsRequest",
     "QueryInstrumentEventsRequest",
+    "QueryRelationalDatasetRequest",
     "QueryTradeTicketsRequest",
     "QueryableKey",
     "Quote",
@@ -2241,6 +2254,9 @@ __all__ = [
     "RelatedEntity",
     "Relation",
     "RelationDefinition",
+    "RelationalDataPointFieldValueResponse",
+    "RelationalDataPointResponse",
+    "RelationalDataSeriesResponse",
     "RelationalDatasetDefinition",
     "RelationalDatasetFieldDefinition",
     "Relationship",
@@ -2572,6 +2588,8 @@ __all__ = [
     "UpsertReferencePortfolioConstituentPropertiesResponse",
     "UpsertReferencePortfolioConstituentsRequest",
     "UpsertReferencePortfolioConstituentsResponse",
+    "UpsertRelationalDataPointDataSeries",
+    "UpsertRelationalDataPointRequest",
     "UpsertResultValuesDataRequest",
     "UpsertReturnsResponse",
     "UpsertSingleStructuredDataResponse",

lusid/models/applicable_entity.py

@@ -0,0 +1,105 @@
+# 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 StrictStr, Field, BaseModel, Field, constr, validator 
+
+class ApplicableEntity(BaseModel):
+    """
+    ApplicableEntity
+    """
+    entity_type:  StrictStr = Field(...,alias="entityType", description="The type of entity (e.g., Instrument, Portfolio) that this DataSeries applies to.") 
+    entity_scope:  Optional[StrictStr] = Field(None,alias="entityScope", description="The scope of the entity.") 
+    identifier_scope:  Optional[StrictStr] = Field(None,alias="identifierScope", description="The scope of the identifier used to uniquely identify the entity.") 
+    identifier_type:  Optional[StrictStr] = Field(None,alias="identifierType", description="The type of identifier (e.g., Figi, Isin) used to uniquely identify the entity.") 
+    identifier_value:  Optional[StrictStr] = Field(None,alias="identifierValue", description="The value of the identifier used to uniquely identify the entity.") 
+    __properties = ["entityType", "entityScope", "identifierScope", "identifierType", "identifierValue"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> ApplicableEntity:
+        """Create an instance of ApplicableEntity 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 entity_scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.entity_scope is None and "entity_scope" in self.__fields_set__:
+            _dict['entityScope'] = None
+
+        # set to None if identifier_scope (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifier_scope is None and "identifier_scope" in self.__fields_set__:
+            _dict['identifierScope'] = None
+
+        # set to None if identifier_type (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifier_type is None and "identifier_type" in self.__fields_set__:
+            _dict['identifierType'] = None
+
+        # set to None if identifier_value (nullable) is None
+        # and __fields_set__ contains the field
+        if self.identifier_value is None and "identifier_value" in self.__fields_set__:
+            _dict['identifierValue'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ApplicableEntity:
+        """Create an instance of ApplicableEntity from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ApplicableEntity.parse_obj(obj)
+
+        _obj = ApplicableEntity.parse_obj({
+            "entity_type": obj.get("entityType"),
+            "entity_scope": obj.get("entityScope"),
+            "identifier_scope": obj.get("identifierScope"),
+            "identifier_type": obj.get("identifierType"),
+            "identifier_value": obj.get("identifierValue")
+        })
+        return _obj

lusid/models/batch_upsert_relational_datasets_response.py

@@ -0,0 +1,132 @@
+# 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, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from lusid.models.error_detail import ErrorDetail
+from lusid.models.link import Link
+from lusid.models.relational_data_point_response import RelationalDataPointResponse
+
+class BatchUpsertRelationalDatasetsResponse(BaseModel):
+    """
+    BatchUpsertRelationalDatasetsResponse
+    """
+    values: Dict[str, RelationalDataPointResponse] = Field(..., description="A list of data points that were successfully upserted.")
+    failed: Optional[Dict[str, ErrorDetail]] = Field(None, description="A list of data points that failed to be upserted, along with the associated error message.")
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
+    links: Optional[conlist(Link)] = None
+    __properties = ["values", "failed", "href", "links"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> BatchUpsertRelationalDatasetsResponse:
+        """Create an instance of BatchUpsertRelationalDatasetsResponse 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 value in values (dict)
+        _field_dict = {}
+        if self.values:
+            for _key in self.values:
+                if self.values[_key]:
+                    _field_dict[_key] = self.values[_key].to_dict()
+            _dict['values'] = _field_dict
+        # override the default output from pydantic by calling `to_dict()` of each value in failed (dict)
+        _field_dict = {}
+        if self.failed:
+            for _key in self.failed:
+                if self.failed[_key]:
+                    _field_dict[_key] = self.failed[_key].to_dict()
+            _dict['failed'] = _field_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 failed (nullable) is None
+        # and __fields_set__ contains the field
+        if self.failed is None and "failed" in self.__fields_set__:
+            _dict['failed'] = None
+
+        # 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) -> BatchUpsertRelationalDatasetsResponse:
+        """Create an instance of BatchUpsertRelationalDatasetsResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return BatchUpsertRelationalDatasetsResponse.parse_obj(obj)
+
+        _obj = BatchUpsertRelationalDatasetsResponse.parse_obj({
+            "values": dict(
+                (_k, RelationalDataPointResponse.from_dict(_v))
+                for _k, _v in obj.get("values").items()
+            )
+            if obj.get("values") is not None
+            else None,
+            "failed": dict(
+                (_k, ErrorDetail.from_dict(_v))
+                for _k, _v in obj.get("failed").items()
+            )
+            if obj.get("failed") is not None
+            else None,
+            "href": obj.get("href"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/loan_principal_repayment_event.py

@@ -19,7 +19,7 @@ import json
 
 from datetime import datetime
 from typing import Any, Dict, List, Optional, Union
-from pydantic.v1 import StrictStr, Field, Field, StrictFloat, StrictInt, StrictStr, conlist, validator 
+from pydantic.v1 import StrictStr, Field, Field, StrictBool, StrictFloat, StrictInt, StrictStr, conlist, validator 
 from lusid.models.instrument_event import InstrumentEvent
 from lusid.models.lapse_election import LapseElection
 
@@ -32,9 +32,10 @@ class LoanPrincipalRepaymentEvent(InstrumentEvent):
     lapse_elections: Optional[conlist(LapseElection)] = Field(None, alias="lapseElections", description="Election for controlling whether the Principal is paid automatically or not.  Exactly one election must be provided.")
     fraction: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Fraction of the outstanding settled principal balance to be repaid. Must be between 0 and 1, inclusive.  Defaults to 1 if not set. Ignored if the field Amount is set to a value different than zero.")
     amount: Optional[Union[StrictFloat, StrictInt]] = Field(None, description="Amount to be repaid (independent of the fraction).  This field is not used at all if not set or set to 0, in this case the fraction field will be used instead.  Otherwise, the fraction field is ignored.")
+    with_interest: Optional[StrictBool] = Field(None, alias="withInterest", description="If set to true, then active contracts whose balance is reduced by the repayment will have  their accrued interest repaid proportionally to the balance reduction.")
     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, CapletFloorletCashFlowEvent") 
     additional_properties: Dict[str, Any] = {}
-    __properties = ["instrumentEventType", "paymentDate", "currency", "lapseElections", "fraction", "amount"]
+    __properties = ["instrumentEventType", "paymentDate", "currency", "lapseElections", "fraction", "amount", "withInterest"]
 
     @validator('instrument_event_type')
     def instrument_event_type_validate_enum(cls, value):
@@ -174,7 +175,8 @@ class LoanPrincipalRepaymentEvent(InstrumentEvent):
             "currency": obj.get("currency"),
             "lapse_elections": [LapseElection.from_dict(_item) for _item in obj.get("lapseElections")] if obj.get("lapseElections") is not None else None,
             "fraction": obj.get("fraction"),
-            "amount": obj.get("amount")
+            "amount": obj.get("amount"),
+            "with_interest": obj.get("withInterest")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

lusid/models/paged_resource_list_of_relational_data_point_response.py

@@ -0,0 +1,121 @@
+# 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, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from lusid.models.link import Link
+from lusid.models.relational_data_point_response import RelationalDataPointResponse
+
+class PagedResourceListOfRelationalDataPointResponse(BaseModel):
+    """
+    PagedResourceListOfRelationalDataPointResponse
+    """
+    next_page:  Optional[StrictStr] = Field(None,alias="nextPage") 
+    previous_page:  Optional[StrictStr] = Field(None,alias="previousPage") 
+    values: conlist(RelationalDataPointResponse) = Field(...)
+    href:  Optional[StrictStr] = Field(None,alias="href") 
+    links: Optional[conlist(Link)] = None
+    __properties = ["nextPage", "previousPage", "values", "href", "links"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> PagedResourceListOfRelationalDataPointResponse:
+        """Create an instance of PagedResourceListOfRelationalDataPointResponse 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 values (list)
+        _items = []
+        if self.values:
+            for _item in self.values:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['values'] = _items
+        # 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 next_page (nullable) is None
+        # and __fields_set__ contains the field
+        if self.next_page is None and "next_page" in self.__fields_set__:
+            _dict['nextPage'] = None
+
+        # set to None if previous_page (nullable) is None
+        # and __fields_set__ contains the field
+        if self.previous_page is None and "previous_page" in self.__fields_set__:
+            _dict['previousPage'] = None
+
+        # 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) -> PagedResourceListOfRelationalDataPointResponse:
+        """Create an instance of PagedResourceListOfRelationalDataPointResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return PagedResourceListOfRelationalDataPointResponse.parse_obj(obj)
+
+        _obj = PagedResourceListOfRelationalDataPointResponse.parse_obj({
+            "next_page": obj.get("nextPage"),
+            "previous_page": obj.get("previousPage"),
+            "values": [RelationalDataPointResponse.from_dict(_item) for _item in obj.get("values")] if obj.get("values") is not None else None,
+            "href": obj.get("href"),
+            "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
+        })
+        return _obj

lusid/models/query_relational_dataset_request.py

@@ -0,0 +1,91 @@
+# 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, Optional
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
+
+class QueryRelationalDatasetRequest(BaseModel):
+    """
+    QueryRelationalDatasetRequest
+    """
+    query_method:  StrictStr = Field(...,alias="queryMethod", description="The method used to query data points. Can be either 'Latest' or 'TimeSeries'.") 
+    filter:  Optional[StrictStr] = Field(None,alias="filter", description="Expression to filter the result set. For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.") 
+    custom_sort_by: Optional[conlist(StrictStr)] = Field(None, alias="customSortBy", description="A list of fields to sort the results by. For example, to sort by a Value field 'AValueField' in descending order, specify 'AValueField DESC'.")
+    __properties = ["queryMethod", "filter", "customSortBy"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> QueryRelationalDatasetRequest:
+        """Create an instance of QueryRelationalDatasetRequest 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 filter (nullable) is None
+        # and __fields_set__ contains the field
+        if self.filter is None and "filter" in self.__fields_set__:
+            _dict['filter'] = None
+
+        # set to None if custom_sort_by (nullable) is None
+        # and __fields_set__ contains the field
+        if self.custom_sort_by is None and "custom_sort_by" in self.__fields_set__:
+            _dict['customSortBy'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> QueryRelationalDatasetRequest:
+        """Create an instance of QueryRelationalDatasetRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return QueryRelationalDatasetRequest.parse_obj(obj)
+
+        _obj = QueryRelationalDatasetRequest.parse_obj({
+            "query_method": obj.get("queryMethod"),
+            "filter": obj.get("filter"),
+            "custom_sort_by": obj.get("customSortBy")
+        })
+        return _obj

lusid/models/relational_data_point_field_value_response.py

@@ -0,0 +1,82 @@
+# 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 StrictStr, Field, BaseModel, Field 
+
+class RelationalDataPointFieldValueResponse(BaseModel):
+    """
+    RelationalDataPointFieldValueResponse
+    """
+    value: Optional[Any] = Field(..., description="The value of the field.")
+    __properties = ["value"]
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def __str__(self):
+        """For `print` and `pprint`"""
+        return pprint.pformat(self.dict(by_alias=False))
+
+    def __repr__(self):
+        """For `print` and `pprint`"""
+        return self.to_str()
+
+    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) -> RelationalDataPointFieldValueResponse:
+        """Create an instance of RelationalDataPointFieldValueResponse 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 value (nullable) is None
+        # and __fields_set__ contains the field
+        if self.value is None and "value" in self.__fields_set__:
+            _dict['value'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> RelationalDataPointFieldValueResponse:
+        """Create an instance of RelationalDataPointFieldValueResponse from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return RelationalDataPointFieldValueResponse.parse_obj(obj)
+
+        _obj = RelationalDataPointFieldValueResponse.parse_obj({
+            "value": obj.get("value")
+        })
+        return _obj