lusid-sdk 2.0.50b0__py3-none-any.whl → 2.0.455__py3-none-any.whl

lusid/api/schemas_api.py

@@ -366,28 +366,26 @@ class SchemasApi:
             _request_auth=_params.get('_request_auth'))
 
     @overload
-    async def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, start : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, skip this number of results")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfValueType:  # noqa: E501
+    async def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ResourceListOfValueType:  # noqa: E501
         ...
 
     @overload
-    def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, start : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, skip this number of results")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfValueType:  # noqa: E501
+    def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=True, **kwargs) -> ResourceListOfValueType:  # noqa: E501
         ...
 
     @validate_arguments
-    def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, start : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, skip this number of results")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfValueType, Awaitable[ResourceListOfValueType]]:  # noqa: E501
+    def get_value_types(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfValueType, Awaitable[ResourceListOfValueType]]:  # noqa: E501
         """[EARLY ACCESS] GetValueTypes: Get value types  # noqa: E501
 
         Gets the available value types for which a schema is available.  # 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_value_types(sort_by, start, limit, async_req=True)
+        >>> thread = api.get_value_types(sort_by, limit, async_req=True)
         >>> result = thread.get()
 
         :param sort_by: Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName
         :type sort_by: List[str]
-        :param start: Optional. When paginating, skip this number of results
-        :type start: int
         :param limit: Optional. When paginating, limit the number of returned results to this many.
         :type limit: int
         :param async_req: Whether to execute the request asynchronously.
@@ -407,23 +405,21 @@ class SchemasApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.get_value_types_with_http_info(sort_by, start, limit, **kwargs)  # noqa: E501
+        return self.get_value_types_with_http_info(sort_by, limit, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_value_types_with_http_info(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, start : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, skip this number of results")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
+    def get_value_types_with_http_info(self, sort_by : Annotated[Optional[conlist(StrictStr)], Field(description="Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName")] = None, limit : Annotated[Optional[StrictInt], Field(description="Optional. When paginating, limit the number of returned results to this many.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] GetValueTypes: Get value types  # noqa: E501
 
         Gets the available value types for which a schema is available.  # 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_value_types_with_http_info(sort_by, start, limit, async_req=True)
+        >>> thread = api.get_value_types_with_http_info(sort_by, limit, async_req=True)
         >>> result = thread.get()
 
         :param sort_by: Optional. Order the results by these fields. Use use the '-' sign to denote descending order e.g. -MyFieldName
         :type sort_by: List[str]
-        :param start: Optional. When paginating, skip this number of results
-        :type start: int
         :param limit: Optional. When paginating, limit the number of returned results to this many.
         :type limit: int
         :param async_req: Whether to execute the request asynchronously.
@@ -455,7 +451,6 @@ class SchemasApi:
 
         _all_params = [
             'sort_by',
-            'start',
             'limit'
         ]
         _all_params.extend(
@@ -491,9 +486,6 @@ class SchemasApi:
             _query_params.append(('sortBy', _params['sort_by']))
             _collection_formats['sortBy'] = 'multi'
 
-        if _params.get('start') is not None:  # noqa: E501
-            _query_params.append(('start', _params['start']))
-
         if _params.get('limit') is not None:  # noqa: E501
             _query_params.append(('limit', _params['limit']))
 

lusid/api/scopes_api.py

@@ -46,6 +46,157 @@ class ScopesApi:
             api_client = ApiClient.get_default()
         self.api_client = api_client
 
+    @overload
+    async def list_entity_scopes(self, entity_type : Annotated[constr(strict=True, max_length=100, min_length=0), Field(..., description="The entity type to list scopes for.")], **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
+        ...
+
+    @overload
+    def list_entity_scopes(self, entity_type : Annotated[constr(strict=True, max_length=100, min_length=0), Field(..., description="The entity type to list scopes for.")], async_req: Optional[bool]=True, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
+        ...
+
+    @validate_arguments
+    def list_entity_scopes(self, entity_type : Annotated[constr(strict=True, max_length=100, min_length=0), Field(..., description="The entity type to list scopes for.")], async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfScopeDefinition, Awaitable[ResourceListOfScopeDefinition]]:  # noqa: E501
+        """ListEntityScopes: List Entity Scopes  # noqa: E501
+
+        List all the scopes for a given entity type that contain data.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.list_entity_scopes(entity_type, async_req=True)
+        >>> result = thread.get()
+
+        :param entity_type: The entity type to list scopes for. (required)
+        :type entity_type: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _request_timeout: timeout setting for this request.
+               If one number provided, it will be total request
+               timeout. It can also be a pair (tuple) of
+               (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: ResourceListOfScopeDefinition
+        """
+        kwargs['_return_http_data_only'] = True
+        if '_preload_content' in kwargs:
+            message = "Error! Please call the list_entity_scopes_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.list_entity_scopes_with_http_info(entity_type, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def list_entity_scopes_with_http_info(self, entity_type : Annotated[constr(strict=True, max_length=100, min_length=0), Field(..., description="The entity type to list scopes for.")], **kwargs) -> ApiResponse:  # noqa: E501
+        """ListEntityScopes: List Entity Scopes  # noqa: E501
+
+        List all the scopes for a given entity type that contain data.  # noqa: E501
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.list_entity_scopes_with_http_info(entity_type, async_req=True)
+        >>> result = thread.get()
+
+        :param entity_type: The entity type to list scopes for. (required)
+        :type entity_type: str
+        :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 for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :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(ResourceListOfScopeDefinition, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = [
+            'entity_type'
+        ]
+        _all_params.extend(
+            [
+                'async_req',
+                '_return_http_data_only',
+                '_preload_content',
+                '_request_timeout',
+                '_request_auth',
+                '_content_type',
+                '_headers'
+            ]
+        )
+
+        # 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 list_entity_scopes" % _key
+                )
+            _params[_key] = _val
+        del _params['kwargs']
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params['entity_type']:
+            _path_params['entityType'] = _params['entity_type']
+
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get('_headers', {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params['Accept'] = self.api_client.select_header_accept(
+            ['text/plain', 'application/json', 'text/json'])  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ['oauth2']  # noqa: E501
+
+        _response_types_map = {
+            '200': "ResourceListOfScopeDefinition",
+            '400': "LusidValidationProblemDetails",
+        }
+
+        return self.api_client.call_api(
+            '/api/scopes/{entityType}', 'GET',
+            _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'),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get('_request_auth'))
+
     @overload
     async def list_scopes(self, filter : Annotated[Optional[constr(strict=True, max_length=16384, min_length=0)], Field(description="Expression to filter the result set.              For example, to filter on the Scope, use \"scope eq 'string'\"              Read more about filtering results from LUSID here https://support.lusid.com/filtering-results-from-lusid.")] = None, **kwargs) -> ResourceListOfScopeDefinition:  # noqa: E501
         ...

lusid/api/scripted_translation_api.py

@@ -33,6 +33,8 @@ from lusid.models.translate_entities_inlined_request import TranslateEntitiesInl
 from lusid.models.translate_entities_request import TranslateEntitiesRequest
 from lusid.models.translate_entities_response import TranslateEntitiesResponse
 from lusid.models.translation_script import TranslationScript
+from lusid.models.upsert_dialect_request import UpsertDialectRequest
+from lusid.models.upsert_translation_script_request import UpsertTranslationScriptRequest
 
 from lusid.api_client import ApiClient
 from lusid.api_response import ApiResponse
@@ -1107,26 +1109,26 @@ class ScriptedTranslationApi:
             _request_auth=_params.get('_request_auth'))
 
     @overload
-    async def upsert_translation_dialect(self, dialect : Annotated[Dialect, Field(..., description="The dialect to upsert.")], **kwargs) -> Dialect:  # noqa: E501
+    async def upsert_translation_dialect(self, upsert_dialect_request : Annotated[UpsertDialectRequest, Field(..., description="The dialect to upsert.")], **kwargs) -> Dialect:  # noqa: E501
         ...
 
     @overload
-    def upsert_translation_dialect(self, dialect : Annotated[Dialect, Field(..., description="The dialect to upsert.")], async_req: Optional[bool]=True, **kwargs) -> Dialect:  # noqa: E501
+    def upsert_translation_dialect(self, upsert_dialect_request : Annotated[UpsertDialectRequest, Field(..., description="The dialect to upsert.")], async_req: Optional[bool]=True, **kwargs) -> Dialect:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_translation_dialect(self, dialect : Annotated[Dialect, Field(..., description="The dialect to upsert.")], async_req: Optional[bool]=None, **kwargs) -> Union[Dialect, Awaitable[Dialect]]:  # noqa: E501
+    def upsert_translation_dialect(self, upsert_dialect_request : Annotated[UpsertDialectRequest, Field(..., description="The dialect to upsert.")], async_req: Optional[bool]=None, **kwargs) -> Union[Dialect, Awaitable[Dialect]]:  # noqa: E501
         """[EARLY ACCESS] UpsertTranslationDialect: Upsert a Dialect.  # noqa: E501
 
         Upsert the given dialect.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_translation_dialect(dialect, async_req=True)
+        >>> thread = api.upsert_translation_dialect(upsert_dialect_request, async_req=True)
         >>> result = thread.get()
 
-        :param dialect: The dialect to upsert. (required)
-        :type dialect: Dialect
+        :param upsert_dialect_request: The dialect to upsert. (required)
+        :type upsert_dialect_request: UpsertDialectRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request.
@@ -1144,21 +1146,21 @@ class ScriptedTranslationApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.upsert_translation_dialect_with_http_info(dialect, **kwargs)  # noqa: E501
+        return self.upsert_translation_dialect_with_http_info(upsert_dialect_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_translation_dialect_with_http_info(self, dialect : Annotated[Dialect, Field(..., description="The dialect to upsert.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_translation_dialect_with_http_info(self, upsert_dialect_request : Annotated[UpsertDialectRequest, Field(..., description="The dialect to upsert.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertTranslationDialect: Upsert a Dialect.  # noqa: E501
 
         Upsert the given dialect.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_translation_dialect_with_http_info(dialect, async_req=True)
+        >>> thread = api.upsert_translation_dialect_with_http_info(upsert_dialect_request, async_req=True)
         >>> result = thread.get()
 
-        :param dialect: The dialect to upsert. (required)
-        :type dialect: Dialect
+        :param upsert_dialect_request: The dialect to upsert. (required)
+        :type upsert_dialect_request: UpsertDialectRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -1187,7 +1189,7 @@ class ScriptedTranslationApi:
         _params = locals()
 
         _all_params = [
-            'dialect'
+            'upsert_dialect_request'
         ]
         _all_params.extend(
             [
@@ -1225,8 +1227,8 @@ class ScriptedTranslationApi:
         _files = {}
         # process the body parameter
         _body_params = None
-        if _params['dialect'] is not None:
-            _body_params = _params['dialect']
+        if _params['upsert_dialect_request'] is not None:
+            _body_params = _params['upsert_dialect_request']
 
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(
@@ -1265,26 +1267,26 @@ class ScriptedTranslationApi:
             _request_auth=_params.get('_request_auth'))
 
     @overload
-    async def upsert_translation_script(self, translation_script : Annotated[TranslationScript, Field(..., description="The translation script to be upserted.")], **kwargs) -> TranslationScript:  # noqa: E501
+    async def upsert_translation_script(self, upsert_translation_script_request : Annotated[UpsertTranslationScriptRequest, Field(..., description="The translation script to be upserted.")], **kwargs) -> TranslationScript:  # noqa: E501
         ...
 
     @overload
-    def upsert_translation_script(self, translation_script : Annotated[TranslationScript, Field(..., description="The translation script to be upserted.")], async_req: Optional[bool]=True, **kwargs) -> TranslationScript:  # noqa: E501
+    def upsert_translation_script(self, upsert_translation_script_request : Annotated[UpsertTranslationScriptRequest, Field(..., description="The translation script to be upserted.")], async_req: Optional[bool]=True, **kwargs) -> TranslationScript:  # noqa: E501
         ...
 
     @validate_arguments
-    def upsert_translation_script(self, translation_script : Annotated[TranslationScript, Field(..., description="The translation script to be upserted.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslationScript, Awaitable[TranslationScript]]:  # noqa: E501
+    def upsert_translation_script(self, upsert_translation_script_request : Annotated[UpsertTranslationScriptRequest, Field(..., description="The translation script to be upserted.")], async_req: Optional[bool]=None, **kwargs) -> Union[TranslationScript, Awaitable[TranslationScript]]:  # noqa: E501
         """[EARLY ACCESS] UpsertTranslationScript: Upsert a translation script.  # noqa: E501
 
         Upserts a translation script to be used for translating financial entities.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_translation_script(translation_script, async_req=True)
+        >>> thread = api.upsert_translation_script(upsert_translation_script_request, async_req=True)
         >>> result = thread.get()
 
-        :param translation_script: The translation script to be upserted. (required)
-        :type translation_script: TranslationScript
+        :param upsert_translation_script_request: The translation script to be upserted. (required)
+        :type upsert_translation_script_request: UpsertTranslationScriptRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _request_timeout: timeout setting for this request.
@@ -1302,21 +1304,21 @@ class ScriptedTranslationApi:
             raise ValueError(message)
         if async_req is not None:
             kwargs['async_req'] = async_req
-        return self.upsert_translation_script_with_http_info(translation_script, **kwargs)  # noqa: E501
+        return self.upsert_translation_script_with_http_info(upsert_translation_script_request, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def upsert_translation_script_with_http_info(self, translation_script : Annotated[TranslationScript, Field(..., description="The translation script to be upserted.")], **kwargs) -> ApiResponse:  # noqa: E501
+    def upsert_translation_script_with_http_info(self, upsert_translation_script_request : Annotated[UpsertTranslationScriptRequest, Field(..., description="The translation script to be upserted.")], **kwargs) -> ApiResponse:  # noqa: E501
         """[EARLY ACCESS] UpsertTranslationScript: Upsert a translation script.  # noqa: E501
 
         Upserts a translation script to be used for translating financial entities.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.upsert_translation_script_with_http_info(translation_script, async_req=True)
+        >>> thread = api.upsert_translation_script_with_http_info(upsert_translation_script_request, async_req=True)
         >>> result = thread.get()
 
-        :param translation_script: The translation script to be upserted. (required)
-        :type translation_script: TranslationScript
+        :param upsert_translation_script_request: The translation script to be upserted. (required)
+        :type upsert_translation_script_request: UpsertTranslationScriptRequest
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the ApiResponse.data will
@@ -1345,7 +1347,7 @@ class ScriptedTranslationApi:
         _params = locals()
 
         _all_params = [
-            'translation_script'
+            'upsert_translation_script_request'
         ]
         _all_params.extend(
             [
@@ -1383,8 +1385,8 @@ class ScriptedTranslationApi:
         _files = {}
         # process the body parameter
         _body_params = None
-        if _params['translation_script'] is not None:
-            _body_params = _params['translation_script']
+        if _params['upsert_translation_script_request'] is not None:
+            _body_params = _params['upsert_translation_script_request']
 
         # set the HTTP header `Accept`
         _header_params['Accept'] = self.api_client.select_header_accept(

lusid/api/transaction_configuration_api.py

@@ -65,7 +65,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_side_definition(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] DeleteSideDefinition: Delete the given side definition  # noqa: E501
+        """DeleteSideDefinition: Delete the given side definition  # noqa: E501
 
         Delete the side which user specify in the request.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -99,7 +99,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_side_definition_with_http_info(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] DeleteSideDefinition: Delete the given side definition  # noqa: E501
+        """DeleteSideDefinition: Delete the given side definition  # noqa: E501
 
         Delete the side which user specify in the request.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -224,7 +224,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_transaction_type(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source that the type is in")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the type's aliases")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] DeleteTransactionType: Delete a transaction type  # noqa: E501
+        """DeleteTransactionType: Delete a transaction type  # noqa: E501
 
         /// WARNING! Changing existing transaction types has a material impact on how data, new and old,  is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -260,7 +260,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_transaction_type_with_http_info(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source that the type is in")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the type's aliases")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] DeleteTransactionType: Delete a transaction type  # noqa: E501
+        """DeleteTransactionType: Delete a transaction type  # noqa: E501
 
         /// WARNING! Changing existing transaction types has a material impact on how data, new and old,  is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -391,7 +391,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_transaction_type_source(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction types for.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[DeletedEntityResponse, Awaitable[DeletedEntityResponse]]:  # noqa: E501
-        """[EXPERIMENTAL] DeleteTransactionTypeSource: Delete all transaction types for the given source and scope  # noqa: E501
+        """DeleteTransactionTypeSource: Delete all transaction types for the given source and scope  # noqa: E501
 
         Delete all the types for the given source and scope.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -425,7 +425,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def delete_transaction_type_source_with_http_info(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction types for.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] DeleteTransactionTypeSource: Delete all transaction types for the given source and scope  # noqa: E501
+        """DeleteTransactionTypeSource: Delete all transaction types for the given source and scope  # noqa: E501
 
         Delete all the types for the given source and scope.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -550,7 +550,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def get_side_definition(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[SideDefinition, Awaitable[SideDefinition]]:  # noqa: E501
-        """[EXPERIMENTAL] GetSideDefinition: Get the side definition for a given side name( or label)  # noqa: E501
+        """GetSideDefinition: Get the side definition for a given side name( or label)  # noqa: E501
 
         Get the side definition user requested.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -586,7 +586,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def get_side_definition_with_http_info(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetSideDefinition: Get the side definition for a given side name( or label)  # noqa: E501
+        """GetSideDefinition: Get the side definition for a given side name( or label)  # noqa: E501
 
         Get the side definition user requested.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -720,7 +720,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def get_transaction_type(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source that the type is in")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TransactionType, Awaitable[TransactionType]]:  # noqa: E501
-        """[EXPERIMENTAL] GetTransactionType: Get a single transaction configuration type  # noqa: E501
+        """GetTransactionType: Get a single transaction configuration type  # noqa: E501
 
         Get a single transaction type. Returns failure if not found  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -758,7 +758,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def get_transaction_type_with_http_info(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source that the type is in")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the type's aliases")], as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction configuration.              Defaults to returning the latest version of the transaction configuration type if not specified")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] GetTransactionType: Get a single transaction configuration type  # noqa: E501
+        """GetTransactionType: Get a single transaction configuration type  # noqa: E501
 
         Get a single transaction type. Returns failure if not found  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -898,7 +898,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def list_side_definitions(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfSideDefinition, Awaitable[ResourceListOfSideDefinition]]:  # noqa: E501
-        """[EXPERIMENTAL] ListSideDefinitions: List the side definitions  # noqa: E501
+        """ListSideDefinitions: List the side definitions  # noqa: E501
 
         List all the side definitions in the given scope  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -932,7 +932,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def list_side_definitions_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] ListSideDefinitions: List the side definitions  # noqa: E501
+        """ListSideDefinitions: List the side definitions  # noqa: E501
 
         List all the side definitions in the given scope  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1060,7 +1060,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def list_transaction_types(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[Dict[str, List[TransactionType]], Awaitable[Dict[str, List[TransactionType]]]]:  # noqa: E501
-        """[EXPERIMENTAL] ListTransactionTypes: List transaction types  # noqa: E501
+        """ListTransactionTypes: List transaction types  # noqa: E501
 
         Get the list of current transaction types. For information on the default transaction types provided with  LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1094,7 +1094,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def list_transaction_types_with_http_info(self, as_at : Annotated[Optional[datetime], Field(description="The asAt datetime at which to retrieve the transaction types. Defaults              to returning the latest versions if not specified.")] = None, scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] ListTransactionTypes: List transaction types  # noqa: E501
+        """ListTransactionTypes: List transaction types  # noqa: E501
 
         Get the list of current transaction types. For information on the default transaction types provided with  LUSID, see https://support.lusid.com/knowledgebase/article/KA-01873/.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1222,7 +1222,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_side_definition(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], side_definition_request : Annotated[SideDefinitionRequest, Field(..., description="The side definition to create or replace.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[SideDefinition, Awaitable[SideDefinition]]:  # noqa: E501
-        """[EXPERIMENTAL] SetSideDefinition: Set a side definition  # noqa: E501
+        """SetSideDefinition: Set a side definition  # noqa: E501
 
         Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1258,7 +1258,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_side_definition_with_http_info(self, side : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The label to uniquely identify the side.")], side_definition_request : Annotated[SideDefinitionRequest, Field(..., description="The side definition to create or replace.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] SetSideDefinition: Set a side definition  # noqa: E501
+        """SetSideDefinition: Set a side definition  # noqa: E501
 
         Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1396,7 +1396,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_side_definitions(self, sides_definition_request : Annotated[conlist(SidesDefinitionRequest), Field(..., description="The list of side definitions to create, or replace.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfSideDefinition, Awaitable[ResourceListOfSideDefinition]]:  # noqa: E501
-        """[EXPERIMENTAL] SetSideDefinitions: Set the given side definitions  # noqa: E501
+        """SetSideDefinitions: Set the given side definitions  # noqa: E501
 
         Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1430,7 +1430,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_side_definitions_with_http_info(self, sides_definition_request : Annotated[conlist(SidesDefinitionRequest), Field(..., description="The list of side definitions to create, or replace.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the side exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] SetSideDefinitions: Set the given side definitions  # noqa: E501
+        """SetSideDefinitions: Set the given side definitions  # noqa: E501
 
         Set a new side definition for use in a transaction type. For more information, see https://support.lusid.com/knowledgebase/article/KA-01875.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1562,7 +1562,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_transaction_type(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction configuration for")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the transaction configuration alias types to uniquely identify the configuration. If this type does not exist, then a new transaction type is created using the body of the request in the given source, without including this type")], transaction_type_request : Annotated[TransactionTypeRequest, Field(..., description="The transaction configuration to set")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[TransactionType, Awaitable[TransactionType]]:  # noqa: E501
-        """[EXPERIMENTAL] SetTransactionType: Set a specific transaction type  # noqa: E501
+        """SetTransactionType: Set a specific transaction type  # noqa: E501
 
         Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created    WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1600,7 +1600,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_transaction_type_with_http_info(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction configuration for")], type : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="One of the transaction configuration alias types to uniquely identify the configuration. If this type does not exist, then a new transaction type is created using the body of the request in the given source, without including this type")], transaction_type_request : Annotated[TransactionTypeRequest, Field(..., description="The transaction configuration to set")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] SetTransactionType: Set a specific transaction type  # noqa: E501
+        """SetTransactionType: Set a specific transaction type  # noqa: E501
 
         Set a transaction type for the given source and type. If the requested transaction type does not exist, it will be created    WARNING! Changing existing transaction types has a material impact on how data, new and old, is processed and aggregated by LUSID, and will affect your whole organisation. Only call this API if you are fully aware of the implications of the change.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1744,7 +1744,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_transaction_type_source(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction types for.")], transaction_type_request : Annotated[conlist(TransactionTypeRequest), Field(..., description="The set of transaction types.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, async_req: Optional[bool]=None, **kwargs) -> Union[ResourceListOfTransactionType, Awaitable[ResourceListOfTransactionType]]:  # noqa: E501
-        """[EXPERIMENTAL] SetTransactionTypeSource: Set the transaction types for the given source and scope  # noqa: E501
+        """SetTransactionTypeSource: Set the transaction types for the given source and scope  # noqa: E501
 
         The complete set of transaction types for the source.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an
@@ -1780,7 +1780,7 @@ class TransactionConfigurationApi:
 
     @validate_arguments
     def set_transaction_type_source_with_http_info(self, source : Annotated[constr(strict=True, max_length=64, min_length=1), Field(..., description="The source to set the transaction types for.")], transaction_type_request : Annotated[conlist(TransactionTypeRequest), Field(..., description="The set of transaction types.")], scope : Annotated[Optional[constr(strict=True, max_length=64, min_length=1)], Field(description="The scope in which the transaction types exists. When not supplied the scope is 'default'.")] = None, **kwargs) -> ApiResponse:  # noqa: E501
-        """[EXPERIMENTAL] SetTransactionTypeSource: Set the transaction types for the given source and scope  # noqa: E501
+        """SetTransactionTypeSource: Set the transaction types for the given source and scope  # noqa: E501
 
         The complete set of transaction types for the source.  # noqa: E501
         This method makes a synchronous HTTP request by default. To make an