lusid-sdk 2.1.898__py3-none-any.whl → 2.1.899__py3-none-any.whl

lusid/__init__.py

@@ -536,6 +536,8 @@ from lusid.models.fund_properties import FundProperties
 from lusid.models.fund_request import FundRequest
 from lusid.models.fund_share_class import FundShareClass
 from lusid.models.fund_valuation_point_data import FundValuationPointData
+from lusid.models.fund_valuation_request import FundValuationRequest
+from lusid.models.fund_valuation_schedule import FundValuationSchedule
 from lusid.models.funding_leg import FundingLeg
 from lusid.models.funding_leg_options import FundingLegOptions
 from lusid.models.future import Future
@@ -1343,6 +1345,7 @@ from lusid.models.user import User
 from lusid.models.valuation_point_data_query_parameters import ValuationPointDataQueryParameters
 from lusid.models.valuation_point_data_request import ValuationPointDataRequest
 from lusid.models.valuation_point_data_response import ValuationPointDataResponse
+from lusid.models.valuation_point_fund_calendar_entry import ValuationPointFundCalendarEntry
 from lusid.models.valuation_point_overview import ValuationPointOverview
 from lusid.models.valuation_point_resource_list_of_accounted_transaction import ValuationPointResourceListOfAccountedTransaction
 from lusid.models.valuation_point_resource_list_of_fund_journal_entry_line import ValuationPointResourceListOfFundJournalEntryLine
@@ -1907,6 +1910,8 @@ __all__ = [
     "FundRequest",
     "FundShareClass",
     "FundValuationPointData",
+    "FundValuationRequest",
+    "FundValuationSchedule",
     "FundingLeg",
     "FundingLegOptions",
     "Future",
@@ -2714,6 +2719,7 @@ __all__ = [
     "ValuationPointDataQueryParameters",
     "ValuationPointDataRequest",
     "ValuationPointDataResponse",
+    "ValuationPointFundCalendarEntry",
     "ValuationPointOverview",
     "ValuationPointResourceListOfAccountedTransaction",
     "ValuationPointResourceListOfFundJournalEntryLine",

lusid/api/funds_api.py

@@ -36,6 +36,8 @@ from lusid.models.fund import Fund
 from lusid.models.fund_definition_request import FundDefinitionRequest
 from lusid.models.fund_properties import FundProperties
 from lusid.models.fund_request import FundRequest
+from lusid.models.fund_valuation_request import FundValuationRequest
+from lusid.models.list_aggregation_response import ListAggregationResponse
 from lusid.models.model_property import ModelProperty
 from lusid.models.operation import Operation
 from lusid.models.paged_resource_list_of_fee import PagedResourceListOfFee
@@ -2444,6 +2446,189 @@ class FundsApi:
             _request_auth=_params.get('_request_auth'))
 
 
+    @overload
+    async def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, **kwargs) -> ListAggregationResponse:  # noqa: E501
+        ...
+
+    @overload
+    def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, async_req: Optional[bool]=True, **kwargs) -> ListAggregationResponse:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def get_valuation_for_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ListAggregationResponse, Awaitable[ListAggregationResponse]]:  # noqa: E501
+        """[EXPERIMENTAL] GetValuationForFund: Perform valuation for a Fund  # noqa: E501
+
+        Perform valuation on a specified Fund.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_valuation_for_fund(scope, code, nav_type_code, fund_valuation_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the Fund (required)
+        :type scope: str
+        :param code: The code of the Fund (required)
+        :type code: str
+        :param nav_type_code: When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.
+        :type nav_type_code: str
+        :param fund_valuation_request: The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics
+        :type fund_valuation_request: FundValuationRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: ListAggregationResponse
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the get_valuation_for_fund_with_http_info method with `_preload_content` instead and obtain raw data from ApiResponse.raw_data"  # noqa: E501
+            raise ValueError(message)
+        if async_req is not None:
+            kwargs['async_req'] = async_req
+        return self.get_valuation_for_fund_with_http_info(scope, code, nav_type_code, fund_valuation_request, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_valuation_for_fund_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund")], code : Annotated[StrictStr, Field(..., description="The code of the Fund")], nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, fund_valuation_request : Annotated[Optional[FundValuationRequest], Field(description="The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+        """[EXPERIMENTAL] GetValuationForFund: Perform valuation for a Fund  # noqa: E501
+
+        Perform valuation on a specified Fund.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_valuation_for_fund_with_http_info(scope, code, nav_type_code, fund_valuation_request, async_req=True)
+        >>> result = thread.get()
+
+        :param scope: The scope of the Fund (required)
+        :type scope: str
+        :param code: The code of the Fund (required)
+        :type code: str
+        :param nav_type_code: When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.
+        :type nav_type_code: str
+        :param fund_valuation_request: The request specifying the dates (or DiaryEntry) on which to calculate a set of valuation metrics
+        :type fund_valuation_request: FundValuationRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the ApiResponse.data will
+                                 be set to none and raw_data will store the
+                                 HTTP response body without reading/decoding.
+                                 Default is True.
+        :type _preload_content: bool, optional
+        :param _return_http_data_only: response data instead of ApiResponse
+                                       object with status code, headers, etc
+        :type _return_http_data_only: bool, optional
+        :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
+        :param opts: Configuration options for this request
+        :type opts: ConfigurationOptions, optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(ListAggregationResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'scope',
+            'code',
+            'nav_type_code',
+            'fund_valuation_request'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers',
+                'opts'
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params['kwargs'].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_valuation_for_fund" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['scope']:
+            _path_params['scope'] = _params['scope']
+
+        if _params['code']:
+            _path_params['code'] = _params['code']
+
+
+        # process the query parameters
+        _query_params = []
+        if _params.get('nav_type_code') is not None:  # noqa: E501
+            _query_params.append(('navTypeCode', _params['nav_type_code']))
+
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params['fund_valuation_request'] is not None:
+            _body_params = _params['fund_valuation_request']
+
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get('_content_type',
+            self.api_client.select_header_content_type(
+                ['application/json-patch+json', 'application/json', 'text/json', 'application/*+json']))
+        if _content_types_list:
+                _header_params['Content-Type'] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "ListAggregationResponse",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/funds/{scope}/{code}/$valuation', 'POST',
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get('async_req'),
+            _return_http_data_only=_params.get('_return_http_data_only'),  # noqa: E501
+            _preload_content=_params.get('_preload_content', True),
+            _request_timeout=_params.get('_request_timeout'),
+            opts=_params.get('opts'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
+
     @overload
     async def get_valuation_point_data(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], valuation_point_data_query_parameters : Annotated[ValuationPointDataQueryParameters, Field(..., description="The arguments to use for querying the Valuation Point data")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the Fund definition. Defaults to returning the latest version of the Fund definition if not specified.")] = None, nav_type_code : Annotated[Optional[StrictStr], Field( description="When provided runs against the specified NAV Type, otherwise the Primary NAV Type will be used.")] = None, **kwargs) -> ValuationPointDataResponse:  # noqa: E501
         ...
@@ -4606,7 +4791,7 @@ class FundsApi:
     def patch_fund(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], operation : Annotated[conlist(Operation), Field(..., description="The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.")], async_req: Optional[bool]=None, **kwargs) -> Union[Fund, Awaitable[Fund]]:  # noqa: E501
         """[EXPERIMENTAL] PatchFund: Patch a Fund.  # noqa: E501
 
-        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, BaseCurrency, PortfolioIds, FundConfigurationId, ShareClassInstrumentScopes, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
+        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, PortfolioIds, FundConfigurationId, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
@@ -4641,7 +4826,7 @@ class FundsApi:
     def patch_fund_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the Fund.")], code : Annotated[StrictStr, Field(..., description="The code of the Fund. Together with the scope this uniquely identifies the Fund.")], operation : Annotated[conlist(Operation), Field(..., description="The json patch document. For more information see: https://datatracker.ietf.org/doc/html/rfc6902.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EXPERIMENTAL] PatchFund: Patch a Fund.  # noqa: E501
 
-        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, BaseCurrency, PortfolioIds, FundConfigurationId, ShareClassInstrumentScopes, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
+        Update fields on a Fund.  The behaviour is defined by the JSON Patch specification.    Currently supported fields are: DisplayName, Description, PortfolioIds, FundConfigurationId, ShareClassInstruments, Type, InceptionDate, DecimalPlaces, PrimaryNavType, AdditionalNavTypes, AborId, YearEndDate.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 

lusid/api/transaction_portfolios_api.py

@@ -101,22 +101,22 @@ class TransactionPortfoliosApi:
 
 
     @overload
-    async def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
+    async def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @overload
-    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
+    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @validate_arguments
-    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
+    def adjust_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
         """AdjustHoldings: Adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.adjust_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.adjust_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -129,6 +129,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -145,17 +149,17 @@ class TransactionPortfoliosApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, **kwargs)  # noqa: E501
+        return self.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def adjust_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def adjust_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The selected set of holdings to adjust to the provided targets for the              transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """AdjustHoldings: Adjust holdings  # noqa: E501
 
         Adjust one or more holdings of the specified transaction portfolio to the provided targets. LUSID will  automatically construct adjustment transactions to ensure that the holdings which have been adjusted are  always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.adjust_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -168,6 +172,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -199,7 +207,9 @@ class TransactionPortfoliosApi:
             'code',
             'effective_at',
             'adjust_holding_request',
-            'reconciliation_methods'
+            'reconciliation_methods',
+            'override_movement_name',
+            'override_offset_movement_name'
         ]
         _all_params.extend(
             [
@@ -244,6 +254,12 @@ class TransactionPortfoliosApi:
             _query_params.append(('reconciliationMethods', _params['reconciliation_methods']))
             _collection_formats['reconciliationMethods'] = 'multi'
 
+        if _params.get('override_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideMovementName', _params['override_movement_name']))
+
+        if _params.get('override_offset_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideOffsetMovementName', _params['override_offset_movement_name']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters
@@ -7313,22 +7329,22 @@ class TransactionPortfoliosApi:
 
 
     @overload
-    async def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
+    async def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @overload
-    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
+    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=True, **kwargs) -> AdjustHolding:  # noqa: E501
         ...
 
     @validate_arguments
-    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
+    def set_holdings(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[AdjustHolding, Awaitable[AdjustHolding]]:  # noqa: E501
         """SetHoldings: Set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.set_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.set_holdings(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -7341,6 +7357,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: Timeout setting. Do not use - use the opts parameter instead
@@ -7357,17 +7377,17 @@ class TransactionPortfoliosApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, **kwargs)  # noqa: E501
+        return self.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def set_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def set_holdings_with_http_info(self, scope : Annotated[StrictStr, Field(..., description="The scope of the transaction portfolio.")], code : Annotated[StrictStr, Field(..., description="The code of the transaction portfolio. Together with the scope this uniquely identifies              the transaction portfolio.")], effective_at : Annotated[StrictStr, Field(..., description="The effective datetime or cut label at which the holdings should be set to the provided targets.")], adjust_holding_request : Annotated[conlist(AdjustHoldingRequest), Field(..., description="The complete set of target holdings for the transaction portfolio.")], reconciliation_methods : Annotated[Optional[conlist(StrictStr)], Field(description="Optional parameter for specifying a reconciliation method: e.g. FxForward.")] = None, override_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter to override movement name for the set holdings.")] = None, override_offset_movement_name : Annotated[Optional[StrictStr], Field( description="Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """SetHoldings: Set holdings  # noqa: E501
 
         Set the holdings of the specified transaction portfolio to the provided targets. LUSID will automatically  construct adjustment transactions to ensure that the entire set of holdings for the transaction portfolio  are always set to the provided targets for the specified effective datetime. Read more about the difference between  adjusting and setting holdings here https://support.lusid.com/docs/how-do-i-manually-adjust-or-set-holdings.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, async_req=True)
+        >>> thread = api.set_holdings_with_http_info(scope, code, effective_at, adjust_holding_request, reconciliation_methods, override_movement_name, override_offset_movement_name, async_req=True)
         >>> result = thread.get()
 
         :param scope: The scope of the transaction portfolio. (required)
@@ -7380,6 +7400,10 @@ class TransactionPortfoliosApi:
         :type adjust_holding_request: List[AdjustHoldingRequest]
         :param reconciliation_methods: Optional parameter for specifying a reconciliation method: e.g. FxForward.
         :type reconciliation_methods: List[str]
+        :param override_movement_name: Optional parameter to override movement name for the set holdings.
+        :type override_movement_name: str
+        :param override_offset_movement_name: Optional parameter will create an additional offset movement for the set holdings with this new name and transaction type: CarryAsPnl
+        :type override_offset_movement_name: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -7411,7 +7435,9 @@ class TransactionPortfoliosApi:
             'code',
             'effective_at',
             'adjust_holding_request',
-            'reconciliation_methods'
+            'reconciliation_methods',
+            'override_movement_name',
+            'override_offset_movement_name'
         ]
         _all_params.extend(
             [
@@ -7456,6 +7482,12 @@ class TransactionPortfoliosApi:
             _query_params.append(('reconciliationMethods', _params['reconciliation_methods']))
             _collection_formats['reconciliationMethods'] = 'multi'
 
+        if _params.get('override_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideMovementName', _params['override_movement_name']))
+
+        if _params.get('override_offset_movement_name') is not None:  # noqa: E501
+            _query_params.append(('overrideOffsetMovementName', _params['override_offset_movement_name']))
+
         # process the header parameters
         _header_params = dict(_params.get('_headers', {}))
         # process the form parameters

lusid/configuration.py

@@ -128,7 +128,7 @@ class Configuration:
                  rate_limit_retries=DEFAULT_RATE_LIMIT_RETRIES) -> None:
         """Constructor
         """
-        self._base_path = "https://www.lusid.com/api" if host is None else host
+        self._base_path = "https://fbn-prd.lusid.com/api" if host is None else host
         """Default Base url
         """
         self.server_index = 0 if server_index is None and host is None else server_index
@@ -445,7 +445,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.8131\n"\
+               "Version of the API: 0.11.8138\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 
@@ -456,7 +456,7 @@ class Configuration:
         """
         return [
             {
-                'url': "https://www.lusid.com/api",
+                'url': "https://fbn-prd.lusid.com/api",
                 'description': "No description provided",
             }
         ]

lusid/models/__init__.py

@@ -445,6 +445,8 @@ from lusid.models.fund_properties import FundProperties
 from lusid.models.fund_request import FundRequest
 from lusid.models.fund_share_class import FundShareClass
 from lusid.models.fund_valuation_point_data import FundValuationPointData
+from lusid.models.fund_valuation_request import FundValuationRequest
+from lusid.models.fund_valuation_schedule import FundValuationSchedule
 from lusid.models.funding_leg import FundingLeg
 from lusid.models.funding_leg_options import FundingLegOptions
 from lusid.models.future import Future
@@ -1252,6 +1254,7 @@ from lusid.models.user import User
 from lusid.models.valuation_point_data_query_parameters import ValuationPointDataQueryParameters
 from lusid.models.valuation_point_data_request import ValuationPointDataRequest
 from lusid.models.valuation_point_data_response import ValuationPointDataResponse
+from lusid.models.valuation_point_fund_calendar_entry import ValuationPointFundCalendarEntry
 from lusid.models.valuation_point_overview import ValuationPointOverview
 from lusid.models.valuation_point_resource_list_of_accounted_transaction import ValuationPointResourceListOfAccountedTransaction
 from lusid.models.valuation_point_resource_list_of_fund_journal_entry_line import ValuationPointResourceListOfFundJournalEntryLine
@@ -1726,6 +1729,8 @@ __all__ = [
     "FundRequest",
     "FundShareClass",
     "FundValuationPointData",
+    "FundValuationRequest",
+    "FundValuationSchedule",
     "FundingLeg",
     "FundingLegOptions",
     "Future",
@@ -2533,6 +2538,7 @@ __all__ = [
     "ValuationPointDataQueryParameters",
     "ValuationPointDataRequest",
     "ValuationPointDataResponse",
+    "ValuationPointFundCalendarEntry",
     "ValuationPointOverview",
     "ValuationPointResourceListOfAccountedTransaction",
     "ValuationPointResourceListOfFundJournalEntryLine",

lusid/models/fund_calendar_entry.py

@@ -17,25 +17,17 @@ import pprint
 import re  # noqa: F401
 import json
 
-from datetime import datetime
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, constr, validator 
-from lusid.models.version import Version
+
+from typing import Any, Dict, Union
+from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, validator 
+import lusid.models
 
 class FundCalendarEntry(BaseModel):
     """
     FundCalendarEntry
     """
-    code:  StrictStr = Field(...,alias="code", description="The unique Code of the Calendar Entry. The Calendar Entry, together with the Fund Scope and Code, uniquely identifies a Fund Calendar Entry") 
-    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Fund Calendar entry.") 
-    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the Fund Calendar entry.") 
-    nav_type_code:  StrictStr = Field(...,alias="navTypeCode", description="The navTypeCode of the Fund Calendar Entry. This is the code of the NAV type that this Calendar Entry is associated with.") 
-    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective at of the Calendar Entry.")
-    as_at: Optional[datetime] = Field(None, alias="asAt", description="The asAt datetime for the Calendar Entry.")
     entry_type:  StrictStr = Field(...,alias="entryType", description="The type of the Fund Calendar Entry. Only 'ValuationPoint' currently supported. The available values are: ValuationPointFundCalendarEntry") 
-    version: Version = Field(...)
-    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested asAt datetime.") 
-    __properties = ["code", "displayName", "description", "navTypeCode", "effectiveAt", "asAt", "entryType", "version", "href"]
+    __properties = ["entryType"]
 
     @validator('entry_type')
     def entry_type_validate_enum(cls, value):
@@ -101,6 +93,23 @@ class FundCalendarEntry(BaseModel):
         allow_population_by_field_name = True
         validate_assignment = True
 
+    # JSON field name that stores the object type
+    __discriminator_property_name = 'entryType'
+
+    # discriminator mappings
+    __discriminator_value_class_map = {
+        'ValuationPointFundCalendarEntry': 'ValuationPointFundCalendarEntry'
+    }
+
+    @classmethod
+    def get_discriminator_value(cls, obj: dict) -> str:
+        """Returns the discriminator value (object type) of the data"""
+        discriminator_value = obj[cls.__discriminator_property_name]
+        if discriminator_value:
+            return cls.__discriminator_value_class_map.get(discriminator_value)
+        else:
+            return None
+
     def __str__(self):
         """For `print` and `pprint`"""
         return pprint.pformat(self.dict(by_alias=False))
@@ -118,7 +127,7 @@ class FundCalendarEntry(BaseModel):
         return json.dumps(self.to_dict())
 
     @classmethod
-    def from_json(cls, json_str: str) -> FundCalendarEntry:
+    def from_json(cls, json_str: str) -> Union(ValuationPointFundCalendarEntry):
         """Create an instance of FundCalendarEntry from a JSON string"""
         return cls.from_dict(json.loads(json_str))
 
@@ -128,39 +137,17 @@ class FundCalendarEntry(BaseModel):
                           exclude={
                           },
                           exclude_none=True)
-        # override the default output from pydantic by calling `to_dict()` of version
-        if self.version:
-            _dict['version'] = self.version.to_dict()
-        # set to None if description (nullable) is None
-        # and __fields_set__ contains the field
-        if self.description is None and "description" in self.__fields_set__:
-            _dict['description'] = 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
-
         return _dict
 
     @classmethod
-    def from_dict(cls, obj: dict) -> FundCalendarEntry:
+    def from_dict(cls, obj: dict) -> Union(ValuationPointFundCalendarEntry):
         """Create an instance of FundCalendarEntry from a dict"""
-        if obj is None:
-            return None
-
-        if not isinstance(obj, dict):
-            return FundCalendarEntry.parse_obj(obj)
-
-        _obj = FundCalendarEntry.parse_obj({
-            "code": obj.get("code"),
-            "display_name": obj.get("displayName"),
-            "description": obj.get("description"),
-            "nav_type_code": obj.get("navTypeCode"),
-            "effective_at": obj.get("effectiveAt"),
-            "as_at": obj.get("asAt"),
-            "entry_type": obj.get("entryType"),
-            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
-            "href": obj.get("href")
-        })
-        return _obj
+        # look up the object type based on discriminator mapping
+        object_type = cls.get_discriminator_value(obj)
+        if object_type:
+            klass = getattr(lusid.models, object_type)
+            return klass.from_dict(obj)
+        else:
+            raise ValueError("FundCalendarEntry failed to lookup discriminator value from " +
+                             json.dumps(obj) + ". Discriminator property name: " + cls.__discriminator_property_name +
+                             ", mapping: " + json.dumps(cls.__discriminator_value_class_map))

lusid/models/fund_valuation_request.py

@@ -0,0 +1,157 @@
+# 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 StrictStr, Field, BaseModel, Field, StrictBool, StrictStr, conlist 
+from lusid.models.aggregate_spec import AggregateSpec
+from lusid.models.fund_valuation_schedule import FundValuationSchedule
+from lusid.models.market_data_overrides import MarketDataOverrides
+from lusid.models.order_by_spec import OrderBySpec
+from lusid.models.order_flow_configuration import OrderFlowConfiguration
+from lusid.models.property_filter import PropertyFilter
+from lusid.models.resource_id import ResourceId
+
+class FundValuationRequest(BaseModel):
+    """
+    Specification object for the parameters of a valuation  # noqa: E501
+    """
+    as_at: Optional[datetime] = Field(None, alias="asAt", description="The asAt date to use.")
+    metrics: conlist(AggregateSpec) = Field(..., description="The set of specifications to calculate or retrieve during the valuation and present in the results. For example:  AggregateSpec('Valuation/PV','Sum') for returning the PV (present value) of holdings  AggregateSpec('Holding/default/Units','Sum') for returning the units of holidays  AggregateSpec('Instrument/default/LusidInstrumentId','Value') for returning the Lusid Instrument identifier")
+    group_by: Optional[conlist(StrictStr)] = Field(None, alias="groupBy", description="The set of items by which to perform grouping. This primarily matters when one or more of the metric operators is a mapping  that reduces set size, e.g. sum or proportion. The group-by statement determines the set of keys by which to break the results out.")
+    filters: Optional[conlist(PropertyFilter)] = Field(None, description="A set of filters to use to reduce the data found in a request. Equivalent to the 'where ...' part of a Sql select statement.  For example, filter a set of values within a given range or matching a particular value.")
+    sort: Optional[conlist(OrderBySpec)] = Field(None, description="A (possibly empty/null) set of specifications for how to order the results.")
+    equip_with_subtotals: Optional[StrictBool] = Field(None, alias="equipWithSubtotals", description="Flag directing the Valuation call to populate the results with subtotals of aggregates.")
+    return_result_as_expanded_types: Optional[StrictBool] = Field(None, alias="returnResultAsExpandedTypes", description="Financially meaningful results can be presented as either simple flat types or more complex expanded types.  For example, the present value (PV) of a holding could be represented either as a simple decimal (with currency implied)  or as a decimal-currency pair. This flag allows either representation to be returned. In the PV example,  the returned value would be the decimal-currency pair if this flag is true, or the decimal only if this flag is false.")
+    include_order_flow: Optional[OrderFlowConfiguration] = Field(None, alias="includeOrderFlow")
+    fund_valuation_schedule: FundValuationSchedule = Field(..., alias="fundValuationSchedule")
+    market_data_overrides: Optional[MarketDataOverrides] = Field(None, alias="marketDataOverrides")
+    corporate_action_source_id: Optional[ResourceId] = Field(None, alias="corporateActionSourceId")
+    __properties = ["asAt", "metrics", "groupBy", "filters", "sort", "equipWithSubtotals", "returnResultAsExpandedTypes", "includeOrderFlow", "fundValuationSchedule", "marketDataOverrides", "corporateActionSourceId"]
+
+    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) -> FundValuationRequest:
+        """Create an instance of FundValuationRequest 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 metrics (list)
+        _items = []
+        if self.metrics:
+            for _item in self.metrics:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['metrics'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in filters (list)
+        _items = []
+        if self.filters:
+            for _item in self.filters:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['filters'] = _items
+        # override the default output from pydantic by calling `to_dict()` of each item in sort (list)
+        _items = []
+        if self.sort:
+            for _item in self.sort:
+                if _item:
+                    _items.append(_item.to_dict())
+            _dict['sort'] = _items
+        # override the default output from pydantic by calling `to_dict()` of include_order_flow
+        if self.include_order_flow:
+            _dict['includeOrderFlow'] = self.include_order_flow.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of fund_valuation_schedule
+        if self.fund_valuation_schedule:
+            _dict['fundValuationSchedule'] = self.fund_valuation_schedule.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of market_data_overrides
+        if self.market_data_overrides:
+            _dict['marketDataOverrides'] = self.market_data_overrides.to_dict()
+        # override the default output from pydantic by calling `to_dict()` of corporate_action_source_id
+        if self.corporate_action_source_id:
+            _dict['corporateActionSourceId'] = self.corporate_action_source_id.to_dict()
+        # 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
+
+        # set to None if group_by (nullable) is None
+        # and __fields_set__ contains the field
+        if self.group_by is None and "group_by" in self.__fields_set__:
+            _dict['groupBy'] = None
+
+        # set to None if filters (nullable) is None
+        # and __fields_set__ contains the field
+        if self.filters is None and "filters" in self.__fields_set__:
+            _dict['filters'] = None
+
+        # set to None if sort (nullable) is None
+        # and __fields_set__ contains the field
+        if self.sort is None and "sort" in self.__fields_set__:
+            _dict['sort'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> FundValuationRequest:
+        """Create an instance of FundValuationRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return FundValuationRequest.parse_obj(obj)
+
+        _obj = FundValuationRequest.parse_obj({
+            "as_at": obj.get("asAt"),
+            "metrics": [AggregateSpec.from_dict(_item) for _item in obj.get("metrics")] if obj.get("metrics") is not None else None,
+            "group_by": obj.get("groupBy"),
+            "filters": [PropertyFilter.from_dict(_item) for _item in obj.get("filters")] if obj.get("filters") is not None else None,
+            "sort": [OrderBySpec.from_dict(_item) for _item in obj.get("sort")] if obj.get("sort") is not None else None,
+            "equip_with_subtotals": obj.get("equipWithSubtotals"),
+            "return_result_as_expanded_types": obj.get("returnResultAsExpandedTypes"),
+            "include_order_flow": OrderFlowConfiguration.from_dict(obj.get("includeOrderFlow")) if obj.get("includeOrderFlow") is not None else None,
+            "fund_valuation_schedule": FundValuationSchedule.from_dict(obj.get("fundValuationSchedule")) if obj.get("fundValuationSchedule") is not None else None,
+            "market_data_overrides": MarketDataOverrides.from_dict(obj.get("marketDataOverrides")) if obj.get("marketDataOverrides") is not None else None,
+            "corporate_action_source_id": ResourceId.from_dict(obj.get("corporateActionSourceId")) if obj.get("corporateActionSourceId") is not None else None
+        })
+        return _obj

lusid/models/fund_valuation_schedule.py

@@ -0,0 +1,131 @@
+# 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, validator 
+
+class FundValuationSchedule(BaseModel):
+    """
+    Specification object for the valuation schedule, how do we determine which days we wish to perform a valuation upon.  # noqa: E501
+    """
+    effective_from:  Optional[StrictStr] = Field(None,alias="effectiveFrom", description="If present, the EffectiveFrom and EffectiveAt dates are interpreted as a range of dates for which to perform a valuation.  In this case, valuation is calculated for the portfolio(s) for each business day in the given range.") 
+    effective_at:  Optional[StrictStr] = Field(None,alias="effectiveAt", description="The market data time, i.e. the time to run the valuation request effective of.") 
+    diary_entry:  Optional[StrictStr] = Field(None,alias="diaryEntry", description="The diary entry to use for the valuation schedule. This is used to determine the date on which the valuation should be performed.") 
+    tenor:  Optional[StrictStr] = Field(None,alias="tenor", description="Tenor, e.g \"1D\", \"1M\" to be used in generating the date schedule when effectiveFrom and effectiveAt are both given and are not the same.") 
+    roll_convention:  Optional[StrictStr] = Field(None,alias="rollConvention", description="When Tenor is given and is \"1M\" or longer, this specifies the rule which should be used to generate the date schedule.  For example, \"EndOfMonth\" to generate end of month dates, or \"1\" to specify the first day of the applicable month.") 
+    holiday_calendars: Optional[conlist(StrictStr)] = Field(None, alias="holidayCalendars", description="The holiday calendar(s) that should be used in determining the date schedule.  Holiday calendar(s) are supplied by their names, for example, \"CoppClark\".  Note that when the calendars are not available (e.g. when the user has insufficient permissions),  a recipe setting will be used to determine whether the whole batch should then fail or whether the calendar not being available should simply be ignored.")
+    valuation_date_times: Optional[conlist(StrictStr)] = Field(None, alias="valuationDateTimes", description="If given, this is the exact set of dates on which to perform a valuation. This will replace/override all other specified values if given.")
+    business_day_convention:  Optional[StrictStr] = Field(None,alias="businessDayConvention", description="When Tenor is given and is not equal to \"1D\", there may be cases where \"date + tenor\" land on non-business days around month end.  In that case, the BusinessDayConvention, e.g. modified following \"MF\" would be applied to determine the next GBD.") 
+    __properties = ["effectiveFrom", "effectiveAt", "diaryEntry", "tenor", "rollConvention", "holidayCalendars", "valuationDateTimes", "businessDayConvention"]
+
+    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) -> FundValuationSchedule:
+        """Create an instance of FundValuationSchedule 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_from (nullable) is None
+        # and __fields_set__ contains the field
+        if self.effective_from is None and "effective_from" in self.__fields_set__:
+            _dict['effectiveFrom'] = None
+
+        # 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 diary_entry (nullable) is None
+        # and __fields_set__ contains the field
+        if self.diary_entry is None and "diary_entry" in self.__fields_set__:
+            _dict['diaryEntry'] = None
+
+        # set to None if tenor (nullable) is None
+        # and __fields_set__ contains the field
+        if self.tenor is None and "tenor" in self.__fields_set__:
+            _dict['tenor'] = None
+
+        # set to None if roll_convention (nullable) is None
+        # and __fields_set__ contains the field
+        if self.roll_convention is None and "roll_convention" in self.__fields_set__:
+            _dict['rollConvention'] = None
+
+        # set to None if holiday_calendars (nullable) is None
+        # and __fields_set__ contains the field
+        if self.holiday_calendars is None and "holiday_calendars" in self.__fields_set__:
+            _dict['holidayCalendars'] = None
+
+        # set to None if valuation_date_times (nullable) is None
+        # and __fields_set__ contains the field
+        if self.valuation_date_times is None and "valuation_date_times" in self.__fields_set__:
+            _dict['valuationDateTimes'] = None
+
+        # set to None if business_day_convention (nullable) is None
+        # and __fields_set__ contains the field
+        if self.business_day_convention is None and "business_day_convention" in self.__fields_set__:
+            _dict['businessDayConvention'] = None
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> FundValuationSchedule:
+        """Create an instance of FundValuationSchedule from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return FundValuationSchedule.parse_obj(obj)
+
+        _obj = FundValuationSchedule.parse_obj({
+            "effective_from": obj.get("effectiveFrom"),
+            "effective_at": obj.get("effectiveAt"),
+            "diary_entry": obj.get("diaryEntry"),
+            "tenor": obj.get("tenor"),
+            "roll_convention": obj.get("rollConvention"),
+            "holiday_calendars": obj.get("holidayCalendars"),
+            "valuation_date_times": obj.get("valuationDateTimes"),
+            "business_day_convention": obj.get("businessDayConvention")
+        })
+        return _obj

lusid/models/valuation_point_fund_calendar_entry.py

@@ -0,0 +1,181 @@
+# 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 StrictStr, Field, Field, StrictStr, constr, validator 
+from lusid.models.fund_calendar_entry import FundCalendarEntry
+from lusid.models.version import Version
+
+class ValuationPointFundCalendarEntry(FundCalendarEntry):
+    """
+    ValuationPointFundCalendarEntry
+    """
+    code:  StrictStr = Field(...,alias="code", description="The unique Code of the Calendar Entry. The Calendar Entry, together with the Fund Scope and Code, uniquely identifies a Fund Calendar Entry") 
+    display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Fund Calendar entry.") 
+    description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the Fund Calendar entry.") 
+    nav_type_code:  StrictStr = Field(...,alias="navTypeCode", description="The navTypeCode of the Fund Calendar Entry. This is the code of the NAV type that this Calendar Entry is associated with.") 
+    effective_at: datetime = Field(..., alias="effectiveAt", description="The effective at of the Calendar Entry.")
+    as_at: datetime = Field(..., alias="asAt", description="The asAt datetime for the Calendar Entry.")
+    status:  StrictStr = Field(...,alias="status", description="The status of the Fund Calendar Entry. Can be 'Estimate', 'Candidate' or 'Final'.") 
+    version: Version = Field(...)
+    href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested asAt datetime.") 
+    entry_type:  StrictStr = Field(...,alias="entryType", description="The type of the Fund Calendar Entry. Only 'ValuationPoint' currently supported. The available values are: ValuationPointFundCalendarEntry") 
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["entryType", "code", "displayName", "description", "navTypeCode", "effectiveAt", "asAt", "status", "version", "href"]
+
+    @validator('entry_type')
+    def entry_type_validate_enum(cls, value):
+        """Validates the enum"""
+
+        # Finbourne have removed enum validation on all models, except for this use case:
+        # Workflow and notification application SDK use the property name 'type' as the discriminator on a number of classes.
+        # During instantiation, the value of 'type' is checked against the enum values, 
+        
+
+        # check it's a class that uses the 'type' property as a discriminator
+        # list of classes can be found by searching for 'actual_instance: Union[' in the generated code
+        if 'ValuationPointFundCalendarEntry' not in [ 
+                                    # For notification application classes
+                                    'AmazonSqsNotificationType',
+                                    'AmazonSqsNotificationTypeResponse',
+                                    'AmazonSqsPrincipalAuthNotificationType',
+                                    'AmazonSqsPrincipalAuthNotificationTypeResponse',
+                                    'AzureServiceBusTypeResponse',
+                                    'AzureServiceBusNotificationType',
+                                    'EmailNotificationType',
+                                    'EmailNotificationTypeResponse',
+                                    'SmsNotificationType',
+                                    'SmsNotificationTypeResponse',
+                                    'WebhookNotificationType',
+                                    'WebhookNotificationTypeResponse',
+                        
+                                    # For workflow application classes
+                                    'CreateChildTasksAction', 
+                                    'RunWorkerAction', 
+                                    'TriggerParentTaskAction',
+                                    'CreateChildTasksActionResponse', 
+                                    'RunWorkerActionResponse',
+                                    'TriggerParentTaskActionResponse',
+                                    'CreateNewTaskActivity',
+                                    'UpdateMatchingTasksActivity',
+                                    'CreateNewTaskActivityResponse', 
+                                    'UpdateMatchingTasksActivityResponse',
+                                    'Fail', 
+                                    'GroupReconciliation', 
+                                    'HealthCheck', 
+                                    'LuminesceView', 
+                                    'SchedulerJob', 
+                                    'Sleep',
+                                    'FailResponse', 
+                                    'GroupReconciliationResponse', 
+                                    'HealthCheckResponse', 
+                                    'LuminesceViewResponse', 
+                                    'SchedulerJobResponse', 
+                                    'SleepResponse']:
+           return value
+        
+        # Only validate the 'type' property of the class
+        if "entry_type" != "type":
+            return value
+
+        if value not in ('ValuationPointFundCalendarEntry'):
+            raise ValueError("must be one of enum values ('ValuationPointFundCalendarEntry')")
+        return 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) -> ValuationPointFundCalendarEntry:
+        """Create an instance of ValuationPointFundCalendarEntry 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={
+                            "additional_properties"
+                          },
+                          exclude_none=True)
+        # override the default output from pydantic by calling `to_dict()` of version
+        if self.version:
+            _dict['version'] = self.version.to_dict()
+        # puts key-value pairs in additional_properties in the top level
+        if self.additional_properties is not None:
+            for _key, _value in self.additional_properties.items():
+                _dict[_key] = _value
+
+        # set to None if description (nullable) is None
+        # and __fields_set__ contains the field
+        if self.description is None and "description" in self.__fields_set__:
+            _dict['description'] = 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> ValuationPointFundCalendarEntry:
+        """Create an instance of ValuationPointFundCalendarEntry from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return ValuationPointFundCalendarEntry.parse_obj(obj)
+
+        _obj = ValuationPointFundCalendarEntry.parse_obj({
+            "entry_type": obj.get("entryType"),
+            "code": obj.get("code"),
+            "display_name": obj.get("displayName"),
+            "description": obj.get("description"),
+            "nav_type_code": obj.get("navTypeCode"),
+            "effective_at": obj.get("effectiveAt"),
+            "as_at": obj.get("asAt"),
+            "status": obj.get("status"),
+            "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None,
+            "href": obj.get("href")
+        })
+        # store additional fields in additional_properties
+        for _key in obj.keys():
+            if _key not in cls.__properties:
+                _obj.additional_properties[_key] = obj.get(_key)
+
+        return _obj

{lusid_sdk-2.1.898.dist-info → lusid_sdk-2.1.899.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lusid-sdk
-Version: 2.1.898
+Version: 2.1.899
 Summary: LUSID API
 Home-page: https://github.com/finbourne/lusid-sdk-python
 License: MIT
@@ -28,7 +28,7 @@ Description-Content-Type: text/markdown
 <a id="documentation-for-api-endpoints"></a>
 ## Documentation for API Endpoints
 
-All URIs are relative to *https://www.lusid.com/api*
+All URIs are relative to *https://fbn-prd.lusid.com/api*
 
 Class | Method | HTTP request | Description
 ------------ | ------------- | ------------- | -------------
@@ -273,6 +273,7 @@ Class | Method | HTTP request | Description
 *FundsApi* | [**get_fund**](docs/FundsApi.md#get_fund) | **GET** /api/funds/{scope}/{code} | [EXPERIMENTAL] GetFund: Get a Fund.
 *FundsApi* | [**get_fund_properties**](docs/FundsApi.md#get_fund_properties) | **GET** /api/funds/{scope}/{code}/properties | [EXPERIMENTAL] GetFundProperties: Get Fund properties
 *FundsApi* | [**get_holdings_for_fund**](docs/FundsApi.md#get_holdings_for_fund) | **POST** /api/funds/{scope}/{code}/$holdings | [EXPERIMENTAL] GetHoldingsForFund: Get holdings for transaction portfolios in a Fund.
+*FundsApi* | [**get_valuation_for_fund**](docs/FundsApi.md#get_valuation_for_fund) | **POST** /api/funds/{scope}/{code}/$valuation | [EXPERIMENTAL] GetValuationForFund: Perform valuation for a Fund
 *FundsApi* | [**get_valuation_point_data**](docs/FundsApi.md#get_valuation_point_data) | **POST** /api/funds/{scope}/{code}/valuationpoints/$query | [EXPERIMENTAL] GetValuationPointData: Get Valuation Point Data for a Fund.
 *FundsApi* | [**get_valuation_point_journal_entry_lines**](docs/FundsApi.md#get_valuation_point_journal_entry_lines) | **POST** /api/funds/{scope}/{code}/valuationpoints/journalentrylines/$query | [EXPERIMENTAL] GetValuationPointJournalEntryLines: Get the Journal Entry lines for the given Fund.
 *FundsApi* | [**get_valuation_point_pnl_summary**](docs/FundsApi.md#get_valuation_point_pnl_summary) | **POST** /api/funds/{scope}/{code}/valuationpoints/pnlsummary/$query | [EXPERIMENTAL] GetValuationPointPnlSummary: Get a PnL summary for the given Valuation Point in the Fund.
@@ -1116,6 +1117,8 @@ Class | Method | HTTP request | Description
  - [FundRequest](docs/FundRequest.md)
  - [FundShareClass](docs/FundShareClass.md)
  - [FundValuationPointData](docs/FundValuationPointData.md)
+ - [FundValuationRequest](docs/FundValuationRequest.md)
+ - [FundValuationSchedule](docs/FundValuationSchedule.md)
  - [FundingLeg](docs/FundingLeg.md)
  - [FundingLegOptions](docs/FundingLegOptions.md)
  - [Future](docs/Future.md)
@@ -1923,6 +1926,7 @@ Class | Method | HTTP request | Description
  - [ValuationPointDataQueryParameters](docs/ValuationPointDataQueryParameters.md)
  - [ValuationPointDataRequest](docs/ValuationPointDataRequest.md)
  - [ValuationPointDataResponse](docs/ValuationPointDataResponse.md)
+ - [ValuationPointFundCalendarEntry](docs/ValuationPointFundCalendarEntry.md)
  - [ValuationPointOverview](docs/ValuationPointOverview.md)
  - [ValuationPointResourceListOfAccountedTransaction](docs/ValuationPointResourceListOfAccountedTransaction.md)
  - [ValuationPointResourceListOfFundJournalEntryLine](docs/ValuationPointResourceListOfFundJournalEntryLine.md)

{lusid_sdk-2.1.898.dist-info → lusid_sdk-2.1.899.dist-info}/RECORD

@@ -1,4 +1,4 @@
-lusid/__init__.py,sha256=KxN8KWC7amErA_n9jmR3em7bnb5svtgbELLqXNXq5vw,145025
+lusid/__init__.py,sha256=DFi3WLP7riZhL0P5akCmxuAFzjhILvneV4jtoaV2lCg,145354
 lusid/api/__init__.py,sha256=yCGwgeQBZ1RZovOUo7Jq24Txz4o6naRgnWAzQVGdHAk,6784
 lusid/api/abor_api.py,sha256=N7Wsh0395mXOvpJI8z0Nrx5OY4nCP5FN9RkbtdHaZbM,165987
 lusid/api/abor_configuration_api.py,sha256=xQ9HcXm02eDFhCdWUHjqFRWl1oQMxm2LNObJ9kcLauU,84216
@@ -29,7 +29,7 @@ lusid/api/entities_api.py,sha256=uImduqQPNkudngZn85Zwk35oAG-JEFvGEpADfJeMf_E,836
 lusid/api/executions_api.py,sha256=ZL8xmOxGpjIJtdU7lCdwcapILElWx7FGBDr8cjskCZs,44076
 lusid/api/fee_types_api.py,sha256=qRVfNS91XHBlD_CrewsPMsetIHB6M0mn3RWbD4LTuro,54620
 lusid/api/fund_configuration_api.py,sha256=18oHsK1ncAobjd8_uDHAI7UbWz4Vm5bPVubFmBdoERo,72665
-lusid/api/funds_api.py,sha256=kA17OvvZw199SqxOJK1HwgesvngfZqrf-oEYFnBMzMw,368797
+lusid/api/funds_api.py,sha256=eRpH4RR-Qt8s8ymPyb1barY-mIMZ9LdG9OIQ377zjAg,379210
 lusid/api/group_reconciliations_api.py,sha256=U8qg3jGd39E1epaiOcjOV_uO8BUivbvKAdujvQ5fFNE,163197
 lusid/api/identifier_definitions_api.py,sha256=x79uhIBI0BJITjwmE7oPMWFOtox60FrrL9Dq4YH60MI,64305
 lusid/api/instrument_event_types_api.py,sha256=RHuGNd8Xf8x0vyvAUFwRNgEB_kpzQTtbsBwlFC3QJcs,79862
@@ -74,13 +74,13 @@ lusid/api/tax_rule_sets_api.py,sha256=ia8zjTdwlgLGC8KDWFBT21agOrfWgn1zC_ik75mNDJ
 lusid/api/timelines_api.py,sha256=uxSMdLi9dI6y8LSaezsLXEVedy9I7A-k22RAKY0Rw4k,109878
 lusid/api/transaction_configuration_api.py,sha256=OHs853-U1RWs2oApEO3raiMxixxiMQMcXu566qsm5v4,103968
 lusid/api/transaction_fees_api.py,sha256=r8Gl44-WYZebyJ_Uw2stLsf3-hPi1bK6Ij64Kx0L6A8,62698
-lusid/api/transaction_portfolios_api.py,sha256=LpY2J0zvjo5uomcE7n2dsJ3GquI2dgB9MuTvt2RKm8E,647596
+lusid/api/transaction_portfolios_api.py,sha256=ei-JM4lSrP1SB5fFc8UhMHw_2HjF4Dhw7pedxjbBsQ8,653380
 lusid/api/transfer_agency_api.py,sha256=m-o3srFi7ZcUcWlO_lpOJiYZJvDSt2JLy7QPcXQoPh4,9545
 lusid/api/translation_api.py,sha256=xpRuTfwQvYBlWe6r_L2EI_uVpXqHFnEOim-i-kVQ85E,20227
 lusid/api/workspace_api.py,sha256=0pCNi3ZCRbIo0NXKa85XE7vtq0WV5YOKcQKvFlcLUaY,120708
 lusid/api_client.py,sha256=ewMTmf9SRurY8pYnUx9jy24RdldPCOa4US38pnrVxjA,31140
 lusid/api_response.py,sha256=6-gnhty6lu8MMAERt3_kTVD7UxQgWFfcjgpcq6iN5IU,855
-lusid/configuration.py,sha256=q2KDYFPHaDno61iXPPwZ1MuhJDmkYuUKGLRX-EYybg8,17972
+lusid/configuration.py,sha256=mvhRaW37KrkYJqTdW9F85j1o5CgsR7S_HvxeYyxARVc,17980
 lusid/exceptions.py,sha256=HIQwgmQrszLlcVCLaqex8dO0laVuejUyOMz7U2ZWJ6s,5326
 lusid/extensions/__init__.py,sha256=dzDHEzpn-9smd2-_UMWQzeyX6Ha4jGf6fnqx7qxKxNI,630
 lusid/extensions/api_client.py,sha256=GzygWg_h603QK1QS2HvAijuE2R1TnvoF6-Yg0CeM3ug,30943
@@ -95,7 +95,7 @@ lusid/extensions/rest.py,sha256=dp-bD_LMR2zAL1tmC3-urhWKLomXx7r5iGN1VteMBVQ,1601
 lusid/extensions/retry.py,sha256=EhW9OKJmGHipxN3H7eROH5DiMlAnfBVl95NQrttcsdg,14834
 lusid/extensions/socket_keep_alive.py,sha256=eX5ICvGfVzUCGIm80Q2RknfFZrBQAdnrcpY61M29V_k,1997
 lusid/extensions/tcp_keep_alive_connector.py,sha256=zaGtUsygRsxB1_4B3x39K3ILwztdhMLDv5bFZV7zmGE,3877
-lusid/models/__init__.py,sha256=YAn7jyFz19hGeXMtDae1IZaZMH2mkBSXnpuaqcDvJNI,137209
+lusid/models/__init__.py,sha256=p3uXRaR67aCwt60V0VT-u1t2rndi4M7yNTIdiYz_S8E,137538
 lusid/models/a2_b_breakdown.py,sha256=-FXgILrvtZXQDmvS0ARaJVGBq5LJ4AH-o3HjujFVmS4,3198
 lusid/models/a2_b_category.py,sha256=WunXUgx-dCnApPeLC8Qo5tVCX8Ywxkehib1vmNqNgNs,2957
 lusid/models/a2_b_data_record.py,sha256=qANTmV1_HUEo4l72-F8qzZjlQxOe0Onc9WPz7h-WWuY,9993
@@ -512,7 +512,7 @@ lusid/models/forward_rate_agreement.py,sha256=2huB94ltI8O9UKnFXc2oAYz278FMwPnaFE
 lusid/models/from_recipe.py,sha256=yUnu4kUNme_mFEHE9p-N6k-ETFBNxvmjsL8u2fKIHyk,2538
 lusid/models/fund.py,sha256=YWMy0wrbBPv5ExNwugI8EelMbRhHvx1ap-TgjtgnMms,11904
 lusid/models/fund_amount.py,sha256=xGFl9O7wn4GTCaMq_SxSkzzo_9Pw3scDIDm3835C64Q,2132
-lusid/models/fund_calendar_entry.py,sha256=OnpYCWCINcPUcDrlV9PRF8OXnX4xfMs3q1UdX8VHwrQ,7861
+lusid/models/fund_calendar_entry.py,sha256=cZYxM3Ch9YFjL2WO8SXqHXgyN8cfmOL1SvW2kMwJ2TM,6555
 lusid/models/fund_calendar_entry_type.py,sha256=QiQwfo_IXs4gOWgS4LSOVyBiflltFK4Ot1BcBP2kBJo,718
 lusid/models/fund_configuration.py,sha256=wC-L5FcOKsoep9C4in6LFrDigHKdB_q2Zno2L-wpVqo,9606
 lusid/models/fund_configuration_properties.py,sha256=b-4hJF9TltJf3lmaSyDjeGUhjjhxbs_-kYZ0MpM8kgk,4620
@@ -527,6 +527,8 @@ lusid/models/fund_properties.py,sha256=SfdvEcARxxk_Akxr92DTGxM_0Ode9T6bBcExeG6K7
 lusid/models/fund_request.py,sha256=edLnVKYbKVHVeTCMCGueA61VRdmBgDJJ5bSnE8jnWAg,7819
 lusid/models/fund_share_class.py,sha256=53IOptw8PPRMiYxzYXNDTTzAi6dUI-3ldTeB3n3Ku_w,12230
 lusid/models/fund_valuation_point_data.py,sha256=e4AoY_OBFZLpMvpoChDzm7oD-KUluVPcfeWH1VdalxQ,7042
+lusid/models/fund_valuation_request.py,sha256=4V-96DXA31XMa1jGVBrRFbwEzW9-bv3jBPHBouD-l6U,9094
+lusid/models/fund_valuation_schedule.py,sha256=amj9iVWaTXe4YEIRoqRscEVDeETaUG13TdOB9o6K_lE,7040
 lusid/models/funding_leg.py,sha256=Q9aTj-1ks89zLPXIs1pxnWxsAujLk00Yd6aZS9j1ra0,11480
 lusid/models/funding_leg_options.py,sha256=_QadJmBSUzIrA_uJrbWvLwKC_E9QzBx3-veegNvEDHc,6806
 lusid/models/future.py,sha256=Ff5Cx4c8zGbb9qJXurFXEPpPRy2ryidlUhsvY39Q894,14539
@@ -1334,6 +1336,7 @@ lusid/models/user.py,sha256=w0Ci15MQI00_eoPaUiWnHnPDzDThuAAR3g4UvlsHt9I,2273
 lusid/models/valuation_point_data_query_parameters.py,sha256=y3zPKw_ygbFGIhxv9Og3xcw-zRU2IF1Koc2SoS4ci4s,2826
 lusid/models/valuation_point_data_request.py,sha256=3haNAxaWwqsd_AhNuf5rxuPC4ehEd9LZiH2TgOG59NI,2274
 lusid/models/valuation_point_data_response.py,sha256=b1YVkLsk4Jr1HgjYMwlqvovYgu6supAdRolHKwWwUo4,6759
+lusid/models/valuation_point_fund_calendar_entry.py,sha256=BX7hnOeLhcNV2ne8ajlozKbaGRsdHpCgnxojT8d6jNY,8756
 lusid/models/valuation_point_overview.py,sha256=91p71fdjFacSMBc3hpd0f9oWtvjuMfmG7Z3IsPhLPHg,5952
 lusid/models/valuation_point_resource_list_of_accounted_transaction.py,sha256=OGdk06THfLMFFXAe0Vq79KeI61dLJXz5UEEUF7rByR4,5541
 lusid/models/valuation_point_resource_list_of_fund_journal_entry_line.py,sha256=wtoGMyc07w7IUadLy_bGIUvexvoY_M50_XDai1Oj4Mg,5543
@@ -1376,6 +1379,6 @@ lusid/models/year_month_day.py,sha256=gwSoxFwlD_wffKdddo1wfvAcLq3Cht3FHQidiaHzAA
 lusid/models/yield_curve_data.py,sha256=I1ZSWxHMgUxj9OQt6i9a4S91KB4_XtmrfFxpN_PV3YQ,9561
 lusid/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lusid/rest.py,sha256=HQT__5LQEMu6_1sLKvYj-DI4FH1DJXBIPYfZCTTyrY4,13431
-lusid_sdk-2.1.898.dist-info/METADATA,sha256=5M6VoUQ-N5KbKr-y7UwnquJ0tgo8w3ym3-meEvLq8hA,230422
-lusid_sdk-2.1.898.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-lusid_sdk-2.1.898.dist-info/RECORD,,
+lusid_sdk-2.1.899.dist-info/METADATA,sha256=JhAud8JksKeMfAB8yfTID9t11C2NZXgOLxTI_wgVg3o,230816
+lusid_sdk-2.1.899.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+lusid_sdk-2.1.899.dist-info/RECORD,,