lusid-sdk 2.1.131__py3-none-any.whl → 2.1.142__py3-none-any.whl

lusid/api/quotes_api.py

@@ -440,7 +440,7 @@ class QuotesApi:
 
     @validate_arguments
     def get_quotes(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the quotes to retrieve.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the quotes. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the quotes. Defaults to return the latest version of each quote if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field(description="The duration of the look back window in an ISO8601 time interval format e.g. P1Y2M3DT4H30M (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime or cut label to generate a effective datetime window inside which a quote must exist to be retrieved.")] = None, request_body : Annotated[Optional[Dict[str, QuoteSeriesId]], Field(description="The time invariant quote series ids of the quotes to retrieve. These need to be               keyed by a unique correlation id allowing the retrieved quote to be identified in the response.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetQuotesResponse, Awaitable[GetQuotesResponse]]:  # noqa: E501
-        """[EARLY ACCESS] GetQuotes: Get quotes  # noqa: E501
+        """GetQuotes: Get quotes  # noqa: E501
 
         Get one or more quotes from a single scope.                Each quote can be identified by its time invariant quote series id.                For each quote series id LUSID will return the most recent quote with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified which defines how far back to look back for a quote from the specified effective datetime.  LUSID will return the most recent quote within this window.                In the request each quote series id must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each quote in the response.                The response will return three collections. One, the successfully retrieved quotes. Two, those that had a  valid quote series id but could not be found. Three, those that failed because LUSID could not construct a valid quote series id from the request.    For the quotes that failed or could not be found a reason will be provided explaining why the quote could not be retrieved.                It is important to always check the failed and not found sets for any unsuccessful results.  The maximum number of quotes that this method can get per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -480,7 +480,7 @@ class QuotesApi:
 
     @validate_arguments
     def get_quotes_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the quotes to retrieve.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which to retrieve the quotes. Defaults to the current LUSID system datetime if not specified.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the quotes. Defaults to return the latest version of each quote if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field(description="The duration of the look back window in an ISO8601 time interval format e.g. P1Y2M3DT4H30M (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime or cut label to generate a effective datetime window inside which a quote must exist to be retrieved.")] = None, request_body : Annotated[Optional[Dict[str, QuoteSeriesId]], Field(description="The time invariant quote series ids of the quotes to retrieve. These need to be               keyed by a unique correlation id allowing the retrieved quote to be identified in the response.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] GetQuotes: Get quotes  # noqa: E501
+        """GetQuotes: Get quotes  # noqa: E501
 
         Get one or more quotes from a single scope.                Each quote can be identified by its time invariant quote series id.                For each quote series id LUSID will return the most recent quote with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified which defines how far back to look back for a quote from the specified effective datetime.  LUSID will return the most recent quote within this window.                In the request each quote series id must be keyed by a unique correlation id. This id is ephemeral and is not stored by LUSID.  It serves only as a way to easily identify each quote in the response.                The response will return three collections. One, the successfully retrieved quotes. Two, those that had a  valid quote series id but could not be found. Three, those that failed because LUSID could not construct a valid quote series id from the request.    For the quotes that failed or could not be found a reason will be provided explaining why the quote could not be retrieved.                It is important to always check the failed and not found sets for any unsuccessful results.  The maximum number of quotes that this method can get per request is 2,000.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/relationships_api.py

@@ -57,7 +57,7 @@ class RelationshipsApi:
 
     @validate_arguments
     def create_relationship(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the relationship")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the relationship")], create_relationship_request : Annotated[CreateRelationshipRequest, Field(..., description="The details of the relationship to create.")], async_req: Optional[bool]=None, **kwargs) -> Union[CompleteRelationship, Awaitable[CompleteRelationship]]:  # noqa: E501
-        """[EARLY ACCESS] CreateRelationship: Create Relationship  # noqa: E501
+        """CreateRelationship: Create Relationship  # noqa: E501
 
         Create a relationship between two entity objects by their identifiers  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -93,7 +93,7 @@ class RelationshipsApi:
 
     @validate_arguments
     def create_relationship_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the relationship")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the relationship")], create_relationship_request : Annotated[CreateRelationshipRequest, Field(..., description="The details of the relationship to create.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] CreateRelationship: Create Relationship  # noqa: E501
+        """CreateRelationship: Create Relationship  # noqa: E501
 
         Create a relationship between two entity objects by their identifiers  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/structured_result_data_api.py

@@ -69,7 +69,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def create_data_map(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] CreateDataMap: Create data map  # noqa: E501
+        """CreateDataMap: Create data map  # noqa: E501
 
         Create or update one or more structured result store address definition data maps in a particular scope. Note these are immutable and cannot be changed once created.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map object in the response.                The response returns both the collection of successfully created or updated data maps, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -103,7 +103,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def create_data_map_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope in which to create or update data maps.")], request_body : Annotated[Dict[str, CreateDataMapRequest], Field(..., description="Individual data map creation requests.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] CreateDataMap: Create data map  # noqa: E501
+        """CreateDataMap: Create data map  # noqa: E501
 
         Create or update one or more structured result store address definition data maps in a particular scope. Note these are immutable and cannot be changed once created.                In the request, each data map must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data map object in the response.                The response returns both the collection of successfully created or updated data maps, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -761,7 +761,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def get_structured_result_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field(description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[GetStructuredResultDataResponse, Awaitable[GetStructuredResultDataResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] GetStructuredResultData: Get structured result data  # noqa: E501
+        """GetStructuredResultData: Get structured result data  # noqa: E501
 
         Retrieve one or more structured result data items from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified to control how far back to look from the specified  effective datetime. LUSID returns the most recent item within this window.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.    The response returns three collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.    For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -799,7 +799,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def get_structured_result_data_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope from which to retrieve data items.")], request_body : Annotated[Dict[str, StructuredResultDataId], Field(..., description="The time invariant set of structured data identifiers to retrieve, keyed by a unique, ephemeral correlation ID.")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the structured result data. Defaults to returning the latest version if not specified.")] = None, max_age : Annotated[Optional[StrictStr], Field(description="The duration of the look-back window in ISO8601 time interval format, for example 'P1Y2M3DT4H30M' (1 year, 2 months, 3 days, 4 hours and 30 minutes).               This is subtracted from the provided effectiveAt datetime to generate a effective datetime window inside which a data item must exist to be retrieved.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetStructuredResultData: Get structured result data  # noqa: E501
+        """GetStructuredResultData: Get structured result data  # noqa: E501
 
         Retrieve one or more structured result data items from a particular scope.                Each item can be identified by its time invariant structured result data identifier. For each ID, LUSID  returns the most recently matched item with respect to the provided (or default) effective datetime.                 An optional maximum age range window can be specified to control how far back to look from the specified  effective datetime. LUSID returns the most recent item within this window.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.    The response returns three collections. The first contains successfully retrieved data items. The second contains those with a  valid identifier but that could not be found. The third contains those that failed because LUSID could not construct a valid identifier from the request.    For the IDs that failed to resolve or could not be found, a reason is provided.                It is important to check the failed sets for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1507,7 +1507,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def upsert_structured_result_data(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], async_req: Optional[bool]=None, **kwargs) -> Union[UpsertStructuredDataResponse, Awaitable[UpsertStructuredDataResponse]]:  # noqa: E501
-        """[BETA] UpsertStructuredResultData: Upsert structured result data  # noqa: E501
+        """UpsertStructuredResultData: Upsert structured result data  # noqa: E501
 
         Create or update one or more structured result data items in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1541,7 +1541,7 @@ class StructuredResultDataApi:
 
     @validate_arguments
     def upsert_structured_result_data_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope in which to create or update data items.")], request_body : Annotated[Dict[str, UpsertStructuredResultDataRequest], Field(..., description="The set of data items to create or update, keyed by a unique, ephemeral correlation ID.")], **kwargs) -> ApiResponse:  # noqa: E501
-        """[BETA] UpsertStructuredResultData: Upsert structured result data  # noqa: E501
+        """UpsertStructuredResultData: Upsert structured result data  # noqa: E501
 
         Create or update one or more structured result data items in a particular scope. An item is updated if it already exists  and created if it does not.                In the request, each data item must be keyed by a unique correlation ID. This ID is ephemeral and not stored by LUSID.  It serves only to easily identify each data item in the response.                The response returns both the collection of successfully created or updated data items, as well as those that failed.  For each failure, a reason is provided.                It is important to check the failed set for any unsuccessful results.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/api/transaction_portfolios_api.py

@@ -3948,7 +3948,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_portfolio_cash_flows(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this               uniquely identifies the portfolio.")], effective_at : Annotated[Optional[StrictStr], Field(description="The valuation (pricing) effective datetime or cut label (inclusive) at which to evaluate the cashflows.  This determines whether cashflows are evaluated in a historic or forward looking context and will, for certain models, affect where data is looked up.  For example, on a swap if the effectiveAt is in the middle of the window, cashflows before it will be historic and resets assumed to exist where if the effectiveAt  is before the start of the range they are forward looking and will be expectations assuming the model supports that.  There is evidently a presumption here about availability of data and that the effectiveAt is realistically on or before the real-world today.")] = None, window_start : Annotated[Optional[StrictStr], Field(description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               There is no lower bound if this is not specified. i.e. it is the minimum date.")] = None, window_end : Annotated[Optional[StrictStr], Field(description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               The upper bound defaults to 'max date' if it is not specified")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the data. Defaults to returning the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the result set.               For example, to return only transactions with a transaction type of 'Buy', specify \"type eq 'Buy'\".               For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field(description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field(description="The code of the given recipeID")] = None, exclude_unsettled_trades : Annotated[Optional[StrictBool], Field(description="If absent or set to false, cashflows will returned based on trade date - more specifically, cashflows from any unsettled trades will be included in the results. If set to true, unsettled trades will be excluded from the result set.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfInstrumentCashFlow, Awaitable[ResourceListOfInstrumentCashFlow]]:  # noqa: E501
-        """[BETA] GetPortfolioCashFlows: Get portfolio cash flows  # noqa: E501
+        """GetPortfolioCashFlows: Get portfolio cash flows  # noqa: E501
 
         Get the set of cash flows that occur in a window for the transaction portfolio's instruments.                Note that grouping can affect the quantity of information returned; where a holding is an amalgamation of one or more (e.g. cash) instruments, a unique  transaction identifier will not be available. The same may go for diagnostic information (e.g. multiple sources of an aggregate cash amount on a date that is  not split out. Grouping at the transaction and instrument level is recommended for those seeking to attribute individual flows.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -3998,7 +3998,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_portfolio_cash_flows_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this               uniquely identifies the portfolio.")], effective_at : Annotated[Optional[StrictStr], Field(description="The valuation (pricing) effective datetime or cut label (inclusive) at which to evaluate the cashflows.  This determines whether cashflows are evaluated in a historic or forward looking context and will, for certain models, affect where data is looked up.  For example, on a swap if the effectiveAt is in the middle of the window, cashflows before it will be historic and resets assumed to exist where if the effectiveAt  is before the start of the range they are forward looking and will be expectations assuming the model supports that.  There is evidently a presumption here about availability of data and that the effectiveAt is realistically on or before the real-world today.")] = None, window_start : Annotated[Optional[StrictStr], Field(description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               There is no lower bound if this is not specified. i.e. it is the minimum date.")] = None, window_end : Annotated[Optional[StrictStr], Field(description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               The upper bound defaults to 'max date' if it is not specified")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the data. Defaults to returning the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the result set.               For example, to return only transactions with a transaction type of 'Buy', specify \"type eq 'Buy'\".               For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field(description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field(description="The code of the given recipeID")] = None, exclude_unsettled_trades : Annotated[Optional[StrictBool], Field(description="If absent or set to false, cashflows will returned based on trade date - more specifically, cashflows from any unsettled trades will be included in the results. If set to true, unsettled trades will be excluded from the result set.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[BETA] GetPortfolioCashFlows: Get portfolio cash flows  # noqa: E501
+        """GetPortfolioCashFlows: Get portfolio cash flows  # noqa: E501
 
         Get the set of cash flows that occur in a window for the transaction portfolio's instruments.                Note that grouping can affect the quantity of information returned; where a holding is an amalgamation of one or more (e.g. cash) instruments, a unique  transaction identifier will not be available. The same may go for diagnostic information (e.g. multiple sources of an aggregate cash amount on a date that is  not split out. Grouping at the transaction and instrument level is recommended for those seeking to attribute individual flows.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5024,7 +5024,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_upsertable_portfolio_cash_flows(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this               uniquely identifies the portfolio.")], effective_at : Annotated[Optional[StrictStr], Field(description="The valuation (pricing) effective datetime or cut label (inclusive) at which to evaluate the cashflows.  This determines whether cashflows are evaluated in a historic or forward looking context and will, for certain models, affect where data is looked up.  For example, on a swap if the effectiveAt is in the middle of the window, cashflows before it will be historic and resets assumed to exist where if the effectiveAt  is before the start of the range they are forward looking and will be expectations assuming the model supports that.  There is evidently a presumption here about availability of data and that the effectiveAt is realistically on or before the real-world today.")] = None, window_start : Annotated[Optional[StrictStr], Field(description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               There is no lower bound if this is not specified. i.e. uses minimum date-time")] = None, window_end : Annotated[Optional[StrictStr], Field(description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               The upper bound defaults to 'max date' if it is not specified")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the result set.               For example, to return only transactions with a transaction type of 'Buy', specify \"type eq 'Buy'\".               For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field(description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field(description="The code of the given recipeID")] = None, exclude_unsettled_trades : Annotated[Optional[StrictBool], Field(description="If absent or set to true, unsettled trades will be excluded from the result set. If set to false, cashflows will returned based on trade date - more specifically, cashflows from any unsettled trades will be included in the results.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfTransaction, Awaitable[ResourceListOfTransaction]]:  # noqa: E501
-        """[BETA] GetUpsertablePortfolioCashFlows: Get upsertable portfolio cash flows.  # noqa: E501
+        """GetUpsertablePortfolioCashFlows: Get upsertable portfolio cash flows.  # noqa: E501
 
         Get the set of cash flows that occur in a window for the given portfolio instruments as a set of upsertable transactions (DTOs).                Note that grouping can affect the quantity of information returned; where a holding is an amalgamation of one or more (e.g. cash) instruments, a unique  transaction identifier will not be available. The same may go for diagnostic information (e.g. multiple sources of an aggregate cash amount on a date that is  not split out. Grouping at the transaction and instrument level is recommended for those seeking to attribute individual flows.                In essence this is identical to the 'GetCashFlows' endpoint but returns the cash flows as a set of transactions suitable for directly putting back into LUSID.  There are a couple of important points:  (1) Internally it can not be fully known where the user wishes to insert these transactions, e.g. portfolio and movement type.      These are therefore defaulted to a sensible option; the user will likely need to change these.  (2) Similarly, knowledge of any properties the user might wish to add to a transaction are unknown and consequently left empty.  (3) The transaction id that is added is simply a concatenation of the original transaction id, instrument id and payment date and direction. The user can happily override this.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5074,7 +5074,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def get_upsertable_portfolio_cash_flows_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the scope this               uniquely identifies the portfolio.")], effective_at : Annotated[Optional[StrictStr], Field(description="The valuation (pricing) effective datetime or cut label (inclusive) at which to evaluate the cashflows.  This determines whether cashflows are evaluated in a historic or forward looking context and will, for certain models, affect where data is looked up.  For example, on a swap if the effectiveAt is in the middle of the window, cashflows before it will be historic and resets assumed to exist where if the effectiveAt  is before the start of the range they are forward looking and will be expectations assuming the model supports that.  There is evidently a presumption here about availability of data and that the effectiveAt is realistically on or before the real-world today.")] = None, window_start : Annotated[Optional[StrictStr], Field(description="The lower bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               There is no lower bound if this is not specified. i.e. uses minimum date-time")] = None, window_end : Annotated[Optional[StrictStr], Field(description="The upper bound effective datetime or cut label (inclusive) from which to retrieve the cashflows.               The upper bound defaults to 'max date' if it is not specified")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the portfolio. Defaults to return the latest version               of each transaction if not specified.")] = None, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the result set.               For example, to return only transactions with a transaction type of 'Buy', specify \"type eq 'Buy'\".               For more information about filtering LUSID results, see https://support.lusid.com/knowledgebase/article/KA-01914.")] = None, recipe_id_scope : Annotated[Optional[StrictStr], Field(description="The scope of the given recipeId")] = None, recipe_id_code : Annotated[Optional[StrictStr], Field(description="The code of the given recipeID")] = None, exclude_unsettled_trades : Annotated[Optional[StrictBool], Field(description="If absent or set to true, unsettled trades will be excluded from the result set. If set to false, cashflows will returned based on trade date - more specifically, cashflows from any unsettled trades will be included in the results.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[BETA] GetUpsertablePortfolioCashFlows: Get upsertable portfolio cash flows.  # noqa: E501
+        """GetUpsertablePortfolioCashFlows: Get upsertable portfolio cash flows.  # noqa: E501
 
         Get the set of cash flows that occur in a window for the given portfolio instruments as a set of upsertable transactions (DTOs).                Note that grouping can affect the quantity of information returned; where a holding is an amalgamation of one or more (e.g. cash) instruments, a unique  transaction identifier will not be available. The same may go for diagnostic information (e.g. multiple sources of an aggregate cash amount on a date that is  not split out. Grouping at the transaction and instrument level is recommended for those seeking to attribute individual flows.                In essence this is identical to the 'GetCashFlows' endpoint but returns the cash flows as a set of transactions suitable for directly putting back into LUSID.  There are a couple of important points:  (1) Internally it can not be fully known where the user wishes to insert these transactions, e.g. portfolio and movement type.      These are therefore defaulted to a sensible option; the user will likely need to change these.  (2) Similarly, knowledge of any properties the user might wish to add to a transaction are unknown and consequently left empty.  (3) The transaction id that is added is simply a concatenation of the original transaction id, instrument id and payment date and direction. The user can happily override this.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5647,7 +5647,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def patch_portfolio_details(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the               scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which the updated or inserted details should become valid.               Defaults to the current LUSID system datetime if not specified.               Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[PortfolioDetails, Awaitable[PortfolioDetails]]:  # noqa: E501
-        """[EARLY ACCESS] PatchPortfolioDetails: Patch portfolio details  # noqa: E501
+        """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
         Create or update certain details for a particular transaction portfolio.  The behaviour is defined by the JSON Patch specification.                Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  Currently supported properties are: SubHoldingKeys, BaseCurrency, AmortisationMethod  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -5685,7 +5685,7 @@ class TransactionPortfoliosApi:
 
     @validate_arguments
     def patch_portfolio_details_with_http_info(self, scope : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The scope of the transaction portfolio.")], code : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The code of the transaction portfolio. Together with the               scope this uniquely identifies the transaction portfolio.")], operation : Annotated[conlist(Operation), Field(..., description="The patch document.")], effective_at : Annotated[Optional[StrictStr], Field(description="The effective datetime or cut label at which the updated or inserted details should become valid.               Defaults to the current LUSID system datetime if not specified.               Note that this will affect all bitemporal entities in the request, but will not be used for any perpetual entities.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EARLY ACCESS] PatchPortfolioDetails: Patch portfolio details  # noqa: E501
+        """PatchPortfolioDetails: Patch portfolio details  # noqa: E501
 
         Create or update certain details for a particular transaction portfolio.  The behaviour is defined by the JSON Patch specification.                Note that not all elements of a transaction portfolio definition are  modifiable once it has been created due to the potential implications for data already stored.  Currently supported properties are: SubHoldingKeys, BaseCurrency, AmortisationMethod  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an

lusid/configuration.py

@@ -373,7 +373,7 @@ class Configuration:
         return "Python SDK Debug Report:\n"\
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
-               "Version of the API: 0.11.6565\n"\
+               "Version of the API: 0.11.6576\n"\
                "SDK Package Version: {package_version}".\
                format(env=sys.platform, pyversion=sys.version, package_version=package_version)
 

lusid/extensions/__init__.py

@@ -3,6 +3,7 @@ from lusid.extensions.configuration_loaders import (
     ConfigurationLoader,
     SecretsFileConfigurationLoader,
     EnvironmentVariablesConfigurationLoader,
+    FileTokenConfigurationLoader,
     ArgsConfigurationLoader,
 )
 from lusid.extensions.api_client import SyncApiClient
@@ -13,6 +14,7 @@ __all__ = [
     "ConfigurationLoader",
     "SecretsFileConfigurationLoader",
     "EnvironmentVariablesConfigurationLoader",
+    "FileTokenConfigurationLoader"
     "ArgsConfigurationLoader",
     "SyncApiClient"
 ]

lusid/extensions/configuration_loaders.py

@@ -1,9 +1,10 @@
 import json
 import os
-from typing import Dict, TextIO, Protocol, Union, Iterable
+from typing import Dict, TextIO, Protocol, Union, Iterable, Optional
 import logging
 from lusid.extensions.proxy_config import ProxyConfig
 from lusid.extensions.api_configuration import ApiConfiguration
+from lusid.extensions.file_access_token import FileAccessToken
 
 logger = logging.getLogger(__name__)
 
@@ -141,10 +142,34 @@ class EnvironmentVariablesConfigurationLoader:
 class ArgsConfigurationLoader:
     """ConfigurationLoader which loads in config from kwargs in constructor
     """
-    def __init__(self, **kwargs):
+    def __init__(self,
+        token_url:Optional[str]=None,
+        api_url:Optional[str]=None,
+        username:Optional[str]=None,
+        password:Optional[str]=None,
+        client_id:Optional[str]=None,
+        client_secret:Optional[str]=None,
+        app_name:Optional[str]=None,
+        certificate_filename:Optional[str]=None,
+        proxy_address:Optional[str]=None,
+        proxy_username:Optional[str]=None,
+        proxy_password:Optional[str]=None,
+        access_token:Optional[str]=None
+        ):
         """kwargs passed to this constructor used to build ApiConfiguration
         """
-        self._kwargs = kwargs
+        self.__token_url = token_url
+        self.__api_url = api_url
+        self.__username = username
+        self.__password = password
+        self.__client_id = client_id
+        self.__client_secret = client_secret
+        self.__app_name = app_name
+        self.__certificate_filename = certificate_filename
+        self.__proxy_address = proxy_address
+        self.__proxy_username = proxy_username
+        self.__proxy_password = proxy_password
+        self.__access_token = access_token
 
     def load_config(self) -> Dict[str, str]:
         """load configuration from kwargs passed to constructor
@@ -155,13 +180,51 @@ class ArgsConfigurationLoader:
             dictionary that can be loaded into an ApiConfiguration object
         """
         logger.debug("loading config from arguments passed to ArgsConfigurationLoader")
-        keys = ENVIRONMENT_CONFIG_KEYS.keys()
-        return {key: self._kwargs.get(key) for key in keys}
+        return {
+            "token_url" : self.__token_url, 
+            "api_url" : self.__api_url, 
+            "username" : self.__username, 
+            "password" : self.__password, 
+            "client_id" : self.__client_id, 
+            "client_secret" : self.__client_secret, 
+            "app_name" : self.__app_name, 
+            "certificate_filename" : self.__certificate_filename, 
+            "proxy_address" : self.__proxy_address, 
+            "proxy_username" : self.__proxy_username, 
+            "proxy_password" : self.__proxy_password, 
+            "access_token" : self.__access_token
+        }
+
+
+class FileTokenConfigurationLoader:
+    """ConfigurationLoader which loads in access token from file
+        if FBN_ACCESS_TOKEN_FILE is set,
+        or if an access_token_location is passed to the initialiser
+    """
+
+    def __init__(
+        self, access_token_location: str = os.getenv("FBN_ACCESS_TOKEN_FILE", "")
+    ):
+        self.access_token = None
+        # if neither are provided we won't want to override config from other loaders
+        if access_token_location is not None and access_token_location != "":
+            self.access_token = FileAccessToken(access_token_location)
+
+    def load_config(self) -> Dict[str, FileAccessToken | None]:
+        """load access token from file
+
+        Returns
+        -------
+        Dict[str, str]
+            dictionary that can be loaded into an ApiConfiguration object
+        """
+        return {"access_token": self.access_token}
 
 
 default_config_loaders = (
     EnvironmentVariablesConfigurationLoader(),
     SecretsFileConfigurationLoader(api_secrets_file="secrets.json"),
+    FileTokenConfigurationLoader()
 )
 
 def get_api_configuration(config_loaders: Iterable[ConfigurationLoader]) -> ApiConfiguration:

lusid/extensions/file_access_token.py

@@ -0,0 +1,42 @@
+import collections
+import datetime
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class FileAccessToken(collections.UserString):
+    """Loads access token from file when requested
+    Acts as a string so can be concatenated to auth headers
+    """
+
+    def __init__(self, access_token_location: str, expiry_time:int = 120):
+        if access_token_location is None or access_token_location == "":
+            raise ValueError("access_token_location must be a non-empty string")
+        self.__access_token_location = access_token_location
+        self.__expiry_time = expiry_time 
+        self.__token_data = {
+            "expires": datetime.datetime.now(),
+            "current_access_token": "",
+        }
+
+    @property
+    def data(self) -> str:
+        """load access token from file
+
+        Returns
+        -------
+        str
+            Access token
+        """
+        if self.__token_data["expires"] <= datetime.datetime.now():
+            try:
+                with open(self.__access_token_location, "r") as access_token_file:
+                    self.__token_data["current_access_token"] = access_token_file.read()
+                self.__token_data["expires"] = (
+                    datetime.datetime.now() + datetime.timedelta(seconds=self.__expiry_time)
+                )
+            except OSError:
+                logger.error("Could not open access token file")
+                raise
+        return self.__token_data["current_access_token"]

lusid/models/__init__.py

@@ -96,6 +96,7 @@ from lusid.models.book_transactions_response import BookTransactionsResponse
 from lusid.models.bool_compliance_parameter import BoolComplianceParameter
 from lusid.models.bool_list_compliance_parameter import BoolListComplianceParameter
 from lusid.models.branch_step import BranchStep
+from lusid.models.branch_step_request import BranchStepRequest
 from lusid.models.bucketed_cash_flow_request import BucketedCashFlowRequest
 from lusid.models.bucketed_cash_flow_response import BucketedCashFlowResponse
 from lusid.models.bucketing_schedule import BucketingSchedule
@@ -125,6 +126,7 @@ from lusid.models.chart_of_accounts import ChartOfAccounts
 from lusid.models.chart_of_accounts_properties import ChartOfAccountsProperties
 from lusid.models.chart_of_accounts_request import ChartOfAccountsRequest
 from lusid.models.check_step import CheckStep
+from lusid.models.check_step_request import CheckStepRequest
 from lusid.models.cleardown_module_details import CleardownModuleDetails
 from lusid.models.cleardown_module_request import CleardownModuleRequest
 from lusid.models.cleardown_module_response import CleardownModuleResponse
@@ -304,7 +306,9 @@ from lusid.models.exercise_event import ExerciseEvent
 from lusid.models.exotic_instrument import ExoticInstrument
 from lusid.models.expanded_group import ExpandedGroup
 from lusid.models.expiry_event import ExpiryEvent
+from lusid.models.fee import Fee
 from lusid.models.fee_accrual import FeeAccrual
+from lusid.models.fee_request import FeeRequest
 from lusid.models.fee_rule import FeeRule
 from lusid.models.fee_rule_upsert_request import FeeRuleUpsertRequest
 from lusid.models.fee_rule_upsert_response import FeeRuleUpsertResponse
@@ -316,6 +320,7 @@ from lusid.models.field_value import FieldValue
 from lusid.models.file_response import FileResponse
 from lusid.models.filter_predicate_compliance_parameter import FilterPredicateComplianceParameter
 from lusid.models.filter_step import FilterStep
+from lusid.models.filter_step_request import FilterStepRequest
 from lusid.models.fixed_leg import FixedLeg
 from lusid.models.fixed_leg_all_of_overrides import FixedLegAllOfOverrides
 from lusid.models.fixed_schedule import FixedSchedule
@@ -371,8 +376,10 @@ from lusid.models.get_structured_result_data_response import GetStructuredResult
 from lusid.models.get_virtual_document_response import GetVirtualDocumentResponse
 from lusid.models.group_by_selector_compliance_parameter import GroupBySelectorComplianceParameter
 from lusid.models.group_by_step import GroupByStep
+from lusid.models.group_by_step_request import GroupByStepRequest
 from lusid.models.group_filter_predicate_compliance_parameter import GroupFilterPredicateComplianceParameter
 from lusid.models.group_filter_step import GroupFilterStep
+from lusid.models.group_filter_step_request import GroupFilterStepRequest
 from lusid.models.group_of_market_data_key_rules import GroupOfMarketDataKeyRules
 from lusid.models.grouped_result_of_address_key import GroupedResultOfAddressKey
 from lusid.models.holding_adjustment import HoldingAdjustment
@@ -428,6 +435,7 @@ from lusid.models.instrument_type import InstrumentType
 from lusid.models.interest_rate_swap import InterestRateSwap
 from lusid.models.interest_rate_swaption import InterestRateSwaption
 from lusid.models.intermediate_compliance_step import IntermediateComplianceStep
+from lusid.models.intermediate_compliance_step_request import IntermediateComplianceStepRequest
 from lusid.models.ir_vol_cube_data import IrVolCubeData
 from lusid.models.ir_vol_dependency import IrVolDependency
 from lusid.models.is_business_day_response import IsBusinessDayResponse
@@ -547,6 +555,7 @@ from lusid.models.paged_resource_list_of_data_type_summary import PagedResourceL
 from lusid.models.paged_resource_list_of_dialect_id import PagedResourceListOfDialectId
 from lusid.models.paged_resource_list_of_diary_entry import PagedResourceListOfDiaryEntry
 from lusid.models.paged_resource_list_of_execution import PagedResourceListOfExecution
+from lusid.models.paged_resource_list_of_fee import PagedResourceListOfFee
 from lusid.models.paged_resource_list_of_fee_type import PagedResourceListOfFeeType
 from lusid.models.paged_resource_list_of_fund import PagedResourceListOfFund
 from lusid.models.paged_resource_list_of_general_ledger_profile_response import PagedResourceListOfGeneralLedgerProfileResponse
@@ -1073,6 +1082,7 @@ __all__ = [
     "BoolComplianceParameter",
     "BoolListComplianceParameter",
     "BranchStep",
+    "BranchStepRequest",
     "BucketedCashFlowRequest",
     "BucketedCashFlowResponse",
     "BucketingSchedule",
@@ -1102,6 +1112,7 @@ __all__ = [
     "ChartOfAccountsProperties",
     "ChartOfAccountsRequest",
     "CheckStep",
+    "CheckStepRequest",
     "CleardownModuleDetails",
     "CleardownModuleRequest",
     "CleardownModuleResponse",
@@ -1281,7 +1292,9 @@ __all__ = [
     "ExoticInstrument",
     "ExpandedGroup",
     "ExpiryEvent",
+    "Fee",
     "FeeAccrual",
+    "FeeRequest",
     "FeeRule",
     "FeeRuleUpsertRequest",
     "FeeRuleUpsertResponse",
@@ -1293,6 +1306,7 @@ __all__ = [
     "FileResponse",
     "FilterPredicateComplianceParameter",
     "FilterStep",
+    "FilterStepRequest",
     "FixedLeg",
     "FixedLegAllOfOverrides",
     "FixedSchedule",
@@ -1348,8 +1362,10 @@ __all__ = [
     "GetVirtualDocumentResponse",
     "GroupBySelectorComplianceParameter",
     "GroupByStep",
+    "GroupByStepRequest",
     "GroupFilterPredicateComplianceParameter",
     "GroupFilterStep",
+    "GroupFilterStepRequest",
     "GroupOfMarketDataKeyRules",
     "GroupedResultOfAddressKey",
     "HoldingAdjustment",
@@ -1405,6 +1421,7 @@ __all__ = [
     "InterestRateSwap",
     "InterestRateSwaption",
     "IntermediateComplianceStep",
+    "IntermediateComplianceStepRequest",
     "IrVolCubeData",
     "IrVolDependency",
     "IsBusinessDayResponse",
@@ -1524,6 +1541,7 @@ __all__ = [
     "PagedResourceListOfDialectId",
     "PagedResourceListOfDiaryEntry",
     "PagedResourceListOfExecution",
+    "PagedResourceListOfFee",
     "PagedResourceListOfFeeType",
     "PagedResourceListOfFund",
     "PagedResourceListOfGeneralLedgerProfileResponse",

lusid/models/access_metadata_operation.py

@@ -28,7 +28,7 @@ class AccessMetadataOperation(BaseModel):
     """
     value: conlist(AccessMetadataValue, min_items=1) = Field(...)
     path: constr(strict=True, max_length=1025, min_length=1) = Field(...)
-    op: StrictStr = Field(..., description="The available values are: add")
+    op: StrictStr = Field(..., description="The available values are: add, remove")
     var_from: Optional[StrictStr] = Field(None, alias="from")
     __properties = ["value", "path", "op", "from"]
 
@@ -42,8 +42,8 @@ class AccessMetadataOperation(BaseModel):
     @validator('op')
     def op_validate_enum(cls, value):
         """Validates the enum"""
-        if value not in ('add'):
-            raise ValueError("must be one of enum values ('add')")
+        if value not in ('add', 'remove'):
+            raise ValueError("must be one of enum values ('add', 'remove')")
         return value
 
     class Config:

lusid/models/applicable_instrument_event.py

@@ -37,8 +37,9 @@ class ApplicableInstrumentEvent(BaseModel):
     instrument_event_id: constr(strict=True, min_length=1) = Field(..., alias="instrumentEventId")
     generated_event: InstrumentEventHolder = Field(..., alias="generatedEvent")
     loaded_event: InstrumentEventHolder = Field(..., alias="loadedEvent")
+    applied_instrument_event_instruction_id: constr(strict=True, min_length=1) = Field(..., alias="appliedInstrumentEventInstructionId")
     transactions: conlist(Transaction) = Field(...)
-    __properties = ["portfolioId", "holdingId", "lusidInstrumentId", "instrumentScope", "instrumentType", "instrumentEventType", "instrumentEventId", "generatedEvent", "loadedEvent", "transactions"]
+    __properties = ["portfolioId", "holdingId", "lusidInstrumentId", "instrumentScope", "instrumentType", "instrumentEventType", "instrumentEventId", "generatedEvent", "loadedEvent", "appliedInstrumentEventInstructionId", "transactions"]
 
     class Config:
         """Pydantic configuration"""
@@ -101,6 +102,7 @@ class ApplicableInstrumentEvent(BaseModel):
             "instrument_event_id": obj.get("instrumentEventId"),
             "generated_event": InstrumentEventHolder.from_dict(obj.get("generatedEvent")) if obj.get("generatedEvent") is not None else None,
             "loaded_event": InstrumentEventHolder.from_dict(obj.get("loadedEvent")) if obj.get("loadedEvent") is not None else None,
+            "applied_instrument_event_instruction_id": obj.get("appliedInstrumentEventInstructionId"),
             "transactions": [Transaction.from_dict(_item) for _item in obj.get("transactions")] if obj.get("transactions") is not None else None
         })
         return _obj

lusid/models/branch_step_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
+from pydantic.v1 import Field, StrictStr, constr, validator
+from lusid.models.compliance_step_request import ComplianceStepRequest
+
+class BranchStepRequest(ComplianceStepRequest):
+    """
+    BranchStepRequest
+    """
+    label: constr(strict=True, max_length=64, min_length=1) = Field(..., description="The label of the compliance step")
+    compliance_step_type_request: StrictStr = Field(..., alias="complianceStepTypeRequest", description=". The available values are: FilterStepRequest, GroupByStepRequest, GroupFilterStepRequest, BranchStepRequest, CheckStepRequest")
+    additional_properties: Dict[str, Any] = {}
+    __properties = ["complianceStepTypeRequest", "label"]
+
+    @validator('compliance_step_type_request')
+    def compliance_step_type_request_validate_enum(cls, value):
+        """Validates the enum"""
+        if value not in ('FilterStepRequest', 'GroupByStepRequest', 'GroupFilterStepRequest', 'BranchStepRequest', 'CheckStepRequest'):
+            raise ValueError("must be one of enum values ('FilterStepRequest', 'GroupByStepRequest', 'GroupFilterStepRequest', 'BranchStepRequest', 'CheckStepRequest')")
+        return value
+
+    class Config:
+        """Pydantic configuration"""
+        allow_population_by_field_name = True
+        validate_assignment = True
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.dict(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> BranchStepRequest:
+        """Create an instance of BranchStepRequest 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)
+        # 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
+
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: dict) -> BranchStepRequest:
+        """Create an instance of BranchStepRequest from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return BranchStepRequest.parse_obj(obj)
+
+        _obj = BranchStepRequest.parse_obj({
+            "compliance_step_type_request": obj.get("complianceStepTypeRequest"),
+            "label": obj.get("label")
+        })
+        # 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