msfabricpysdkcore 0.1.8__py3-none-any.whl → 0.2.2__py3-none-any.whl

msfabricpysdkcore/coreapi.py

@@ -65,6 +65,193 @@ class FabricClientCore(FabricClient):
         items = [Capacity.from_dict(i) for i in items]
         return items
     
+    # Connections
+
+    # POST https://api.fabric.microsoft.com/v1/connections/{connectionId}/roleAssignments
+
+    def add_connection_role_assignment(self, connection_id, principal, role):
+        """Add a role assignment to a connection
+        Args:
+            connection_id (str): The ID of the connection
+            principal (str): The principal
+            role (str): The role
+        Returns:
+            dict: The role assignment
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}/roleAssignments"
+
+        body = {
+            'principal': principal,
+            'role': role
+        }
+
+        response_json = self.calling_routine(url, operation="POST", body=body, response_codes=[201, 429],
+                                             error_message="Error adding connection role assignment", return_format="json")
+        return response_json
+
+    def create_connection(self, connection_request):
+        """Create a connection
+        Args:
+            connection_request (dict): The connection request
+        Returns:
+            dict: The connection
+        """
+        url = "https://api.fabric.microsoft.com/v1/connections"
+
+        response_json = self.calling_routine(url, operation="POST", body=connection_request, response_codes=[201, 429],
+                                             error_message="Error creating connection", return_format="json")
+        return response_json 
+
+    def delete_connection(self, connection_id):
+        """Delete a connection
+        Args:
+            connection_id (str): The ID of the connection
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                        error_message="Error deleting connection")
+        return response.status_code
+    
+    def delete_connection_role_assignment(self, connection_id, connection_role_assignment_id):
+        """Delete a role assignment for a connection
+        Args:
+            connection_id (str): The ID of the connection
+            connection_role_assignment_id (str): The ID of the role assignment
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}/roleAssignments/{connection_role_assignment_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                        error_message="Error deleting connection role assignment")
+        return response.status_code
+                          
+
+    def get_connection(self, connection_id = None, connection_name = None):
+        """Get a connection
+        Args:
+            connection_id (str): The ID of the connection
+        Returns:
+            dict: The connection
+        """
+        if connection_id is None and connection_name is not None:
+            connections = self.list_connections()
+            for connection in connections:
+                if connection["displayName"] == connection_name:
+                    connection_id = connection["id"]
+                    break
+        if connection_id is None:
+            raise Exception("Please provide either connection_id or connection_name")
+    
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}"
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting connection", return_format="json")
+        return response_json
+    
+    # GET https://api.fabric.microsoft.com/v1/connections/{connectionId}/roleAssignments/{connectionRoleAssignmentId}
+    def get_connection_role_assignment(self, connection_id, connection_role_assignment_id):
+        """Get a role assignment for a connection
+        Args:
+            connection_id (str): The ID of the connection
+            connection_role_assignment_id (str): The ID of the role assignment
+        Returns:
+            dict: The role assignment
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}/roleAssignments/{connection_role_assignment_id}"
+
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting connection role assignment", return_format="json")
+        return response_json
+    
+    def list_connection_role_assignments(self, connection_id):
+        """List role assignments for a connection
+        Args:
+            connection_id (str): The ID of the connection
+        Returns:
+            list: The list of role assignments
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}/roleAssignments"
+
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing connection role assignments", return_format="value_json", paging=True)
+        return items
+    
+    def list_connections(self):
+        """Returns a list of on-premises, virtual network and cloud connections the user has permission for.
+        Returns:
+            list: The list of connections
+        """
+        # GET https://api.fabric.microsoft.com/v1/connections
+
+        url = "https://api.fabric.microsoft.com/v1/connections"
+
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing connections", return_format="value_json", paging=True)
+        
+        return items
+    
+    def list_supported_connection_types(self, gateway_id = None, show_all_creation_methods = None):
+        """List supported connection types
+        Args:
+            gateway_id (str): The ID of the gateway
+            show_all_creation_methods (bool): Whether to show all creation methods
+        Returns:
+            list: The list of supported connection types
+        """
+        url = "https://api.fabric.microsoft.com/v1/connections/supportedConnectionTypes"
+
+        if gateway_id:
+            url += f"?gatewayId={gateway_id}"
+        if show_all_creation_methods:
+            if "?" in url:
+                url += "&"
+            else:
+                url += "?"
+            url += "showAllCreationMethods=" + str(show_all_creation_methods)
+        
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing supported connection types", return_format="value_json", paging=True)
+        
+        return items
+    
+    def update_connection(self, connection_id, connection_request):
+        """Update a connection
+        Args:
+            connection_id (str): The ID of the connection
+            connection_request (dict): The connection request
+        Returns:
+            dict: The updated connection
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}"
+
+        response_json = self.calling_routine(url, operation="PATCH", body=connection_request, response_codes=[200, 429],
+                                             error_message="Error updating connection", return_format="json")
+        return response_json
+    
+    # PATCH https://api.fabric.microsoft.com/v1/connections/{connectionId}/roleAssignments/{connectionRoleAssignmentId}
+
+    def update_connection_role_assignment(self, connection_id, connection_role_assignment_id, role):
+        """Update a role assignment for a connection
+        Args:
+            connection_id (str): The ID of the connection
+            connection_role_assignment_id (str): The ID of the role assignment
+            role (str): The role
+        Returns:
+            dict: The role assignment
+        """
+        url = f"https://api.fabric.microsoft.com/v1/connections/{connection_id}/roleAssignments/{connection_role_assignment_id}"
+
+        body = {
+            'role': role
+        }
+
+        response_json = self.calling_routine(url, operation="PATCH", body=body, response_codes=[200, 429],
+                                             error_message="Error updating connection role assignment", return_format="json")
+        return response_json
+        
     # Deployment Pipelines
 
     def deploy_stage_content(self, deployment_pipeline_id, source_stage_id, target_stage_id, created_workspace_details = None,
@@ -268,6 +455,211 @@ class FabricClientCore(FabricClient):
         response = self.calling_routine(url, operation="POST", response_codes=[200, 429], error_message="Error revoking external data share", return_format="response")
         return response.status_code
     
+    # Gateways
+
+    def add_gateway_role_assignment(self, gateway_id, principal, role):
+        """Add a role assignment to a gateway
+        Args:
+            gateway_id (str): The ID of the gateway
+            principal (str): The principal
+            role (str): The role
+        Returns:
+            dict: The role assignment
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/roleAssignments"
+
+        body = {
+            'principal': principal,
+            'role': role
+        }
+
+        response_json = self.calling_routine(url, operation="POST", body=body, response_codes=[201, 429],
+                                             error_message="Error adding gateway role assignment", return_format="json")
+        return response_json
+
+    def create_gateway(self, gateway_request):
+        """Create a gateway
+        Args:
+            gateway_request (dict): The gateway request
+        Returns:
+            dict: The gateway
+        """
+        url = "https://api.fabric.microsoft.com/v1/gateways"
+
+        response_json = self.calling_routine(url, operation="POST", body=gateway_request, response_codes=[200, 201, 429],
+                                             error_message="Error creating gateway", return_format="json")
+        return response_json
+    
+    def delete_gateway(self, gateway_id):
+        """Delete a gateway
+        Args:
+            gateway_id (str): The ID of the gateway
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                        error_message="Error deleting gateway")
+        return response.status_code
+    
+    def delete_gateway_member(self, gateway_id, gateway_member_id):
+        """Delete a gateway member
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_member_id (str): The ID of the gateway member
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/members/{gateway_member_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                        error_message="Error deleting gateway member")
+        return response.status_code
+
+    def delete_gateway_role_assignment(self, gateway_id, gateway_role_assignment_id):
+        """Delete a gateway role assignment
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_role_assignment_id (str): The ID of the gateway role assignment
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/roleAssignments/{gateway_role_assignment_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                        error_message="Error deleting gateway role assignment")
+        return response.status_code
+    
+    def get_gateway(self, gateway_id = None, gateway_name = None):
+        """Get a gateway
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_name (str): The name of the gateway
+        Returns:
+            dict: The gateway
+        """
+        if gateway_id is None and gateway_name is not None:
+            gateways = self.list_gateways()
+            for gateway in gateways:
+                if gateway["displayName"] == gateway_name:
+                    gateway_id = gateway["id"]
+                    break
+        if gateway_id is None:
+            raise Exception("Please provide either gateway_id or gateway_name")
+    
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}"
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting gateway", return_format="json")
+        return response_json
+
+    def get_gateway_role_assignment(self, gateway_id, gateway_role_assignment_id):
+        """Get a gateway role assignment
+        Args:
+            gateway_id (str): The
+            gateway_role_assignment_id (str): The ID of the gateway role assignment
+        Returns:
+            dict: The gateway role assignment
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/roleAssignments/{gateway_role_assignment_id}"
+
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting gateway role assignment", return_format="json")
+        return response_json
+    
+    def list_gateway_members(self, gateway_id):
+        """List gateway members
+        Args:
+            gateway_id (str): The ID of the gateway
+        Returns:
+            list: The list of gateway members
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/members"
+
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing gateway members", return_format="value_json", paging=True)
+        return items
+    
+    def list_gateway_role_assignments(self, gateway_id):
+        """List gateway role assignments
+        Args:
+            gateway_id (str): The ID of the gateway
+        Returns:
+            list: The list of gateway role assignments
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/roleAssignments"
+
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing gateway role assignments", return_format="value_json", paging=True)
+        return items
+    
+    def list_gateways(self):
+        """List gateways
+        Returns:
+            list: The list of gateways
+        """
+        url = "https://api.fabric.microsoft.com/v1/gateways"
+
+        items = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                     error_message="Error listing gateways", return_format="value_json", paging=True)
+        return items
+    
+    def update_gateway(self, gateway_id, gateway_request):
+        """Update a gateway
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_request (dict): The gateway request
+        Returns:
+            dict: The updated gateway
+        """
+
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}"
+
+        response_json = self.calling_routine(url, operation="PATCH", body=gateway_request, response_codes=[200, 429],
+                                             error_message="Error updating gateway", return_format="json")
+        return response_json
+    
+    def update_gateway_member(self, gateway_id, gateway_member_id, display_name, enabled):
+        """Update a gateway member
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_member_id (str): The ID of the gateway member
+            display_name (str): The display name of the gateway member
+            enabled (bool): Whether the gateway member is enabled
+        Returns:
+            dict: The updated gateway member
+        """
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/members/{gateway_member_id}"
+
+        body = {
+            'displayName': display_name,
+            'enabled': enabled
+        }
+
+        response_json = self.calling_routine(url, operation="PATCH", body=body, response_codes=[200, 429],
+                                             error_message="Error updating gateway member", return_format="json")
+        return response_json
+
+    def update_gateway_role_assignment(self, gateway_id, gateway_role_assignment_id, role):
+        """Update a gateway role assignment
+        Args:
+            gateway_id (str): The ID of the gateway
+            gateway_role_assignment_id (str): The ID of the gateway role assignment
+            role (str): The role
+        Returns:
+            dict: The updated gateway role assignment
+        """
+
+        url = f"https://api.fabric.microsoft.com/v1/gateways/{gateway_id}/roleAssignments/{gateway_role_assignment_id}"
+
+        body = {
+            'role': role
+        }
+
+        response_json = self.calling_routine(url, operation="PATCH", body=body, response_codes=[200, 429],
+                                             error_message="Error updating gateway role assignment", return_format="json")
+        return response_json
+
     # Git
     
     def commit_to_git(self, workspace_id, mode, comment=None, items=None, workspace_head=None):
@@ -348,6 +740,22 @@ class FabricClientCore(FabricClient):
                                              error_message="Error getting git connection info", return_format="json")
 
         return response_json
+    
+    def get_my_git_credentials(self, workspace_id):
+    # GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/git/myGitCredentials
+        """Get my git credentials
+        Args:
+            workspace_id (str): The ID of the workspace
+        Returns:
+            dict: The git credentials
+        """
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/git/myGitCredentials"
+
+        response_json = self.calling_routine(url=url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting git credentials", return_format="json")
+
+        return response_json
 
     def git_get_status(self, workspace_id):
         """Get git connection status
@@ -405,6 +813,23 @@ class FabricClientCore(FabricClient):
 
         return response.status_code
 
+    def update_my_git_credentials(self, workspace_id, git_credentials):
+        #PATCH https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/git/myGitCredentials
+        """Update my git credentials
+        Args:
+            git_credentials (dict): The git provider details
+        Returns:
+            dict: The response object
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/git/myGitCredentials"
+
+        body = git_credentials
+
+        response = self.calling_routine(url=url, operation="PATCH", body=body,
+                                        response_codes=[200, 429],
+                                        error_message="Error updating git credentials", return_format="json") 
+        
+        return response
 
     # Items
 
@@ -442,12 +867,16 @@ class FabricClientCore(FabricClient):
             return self.get_eventstream(workspace_id, item_dict["id"])
         if item_dict["type"] == "Eventhouse":
             return self.get_eventhouse(workspace_id, item_dict["id"])
+        if item_dict["type"] == "KQLDashboard":
+            return self.get_kql_dashboard(workspace_id, item_dict["id"])
         if item_dict["type"] == "KQLDatabase":
             return self.get_kql_database(workspace_id, item_dict["id"])
         if item_dict["type"] == "KQLQueryset":
             return self.get_kql_queryset(workspace_id, item_dict["id"])
         if item_dict["type"] == "Lakehouse":
             return self.get_lakehouse(workspace_id, item_dict["id"])
+        if item_dict["type"] == "MirroredDatabase":
+            return self.get_mirrored_database(workspace_id, item_dict["id"])
         if item_dict["type"] == "MLExperiment":
             return self.get_ml_experiment(workspace_id, item_dict["id"])
         if item_dict["type"] == "MLModel":
@@ -510,14 +939,21 @@ class FabricClientCore(FabricClient):
                     "environments",
                     "eventhouses",
                     "eventstreams",
+                    "GraphQLApis",
                     "kqlDatabases",
+                    "kqlDashboards",
+                    "kqlQuerysets",
                     "lakehouses",
+                    "mirroredDatabases",
                     "mlExperiments", 
-                    "mlModels", 
-                    "notebooks", 
+                    "mlModels",
+                    "mountedDataFactories", 
+                    "notebooks",
+                    "reflexes", 
                     "reports", 
                     "semanticModels", 
-                    "sparkJobDefinitions", 
+                    "sparkJobDefinitions",
+                    "SQLDatabases",
                     "warehouses"]:
             
             if type == "kqlDatabases":
@@ -528,7 +964,6 @@ class FabricClientCore(FabricClient):
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/{type}"
             body.pop('type')
 
-
         item_dict = self.calling_routine(url, operation="POST", 
                                          body=body, response_codes=[201, 202, 429], 
                                          error_message="Error creating item", return_format="json+operation_result",
@@ -544,14 +979,21 @@ class FabricClientCore(FabricClient):
                             "environments": "Environment",
                             "eventhouses": "Eventhouse",
                             "eventstreams": "Eventstream",
+                            "GraphQLApis": "GraphQLApi",
+                            "kqlDashboards": "KQLDashboard",
                             "kqlDatabases": "KQLDatabase",
-                            "lakehouses": "Lakehouse", 
+                            "kqlQuerysets": "KQLQueryset",
+                            "lakehouses": "Lakehouse",
+                            "mirroredDatabases": "MirroredDatabase",
                             "mlExperiments": "MLExperiment",
                             "mlModels": "MLModel", 
-                            "notebooks": "Notebook", 
+                            "mountedDataFactories": "MountedDataFactory",
+                            "notebooks": "Notebook",
+                            "reflexes": "Reflex",
                             "reports": "Report", 
                             "semanticModels": "SemanticModel",
-                            "sparkJobDefinitions": "SparkJobDefinition", 
+                            "sparkJobDefinitions": "SparkJobDefinition",
+                            "SQLDatabases": "SQLDatabase",
                             "warehouses": "Warehouse"
                             }
             
@@ -590,6 +1032,8 @@ class FabricClientCore(FabricClient):
                 return self.get_data_pipeline(workspace_id, item_id, item_name)
             if item_type.lower() == "eventstream":
                 return self.get_eventstream(workspace_id, item_id, item_name)
+            if item_type.lower() == "kqldashboard":
+                return self.get_kql_dashboard(workspace_id, item_id, item_name)
             if item_type.lower() == "kqldatabase":
                 return self.get_kql_database(workspace_id, item_id, item_name)
             if item_type.lower() == "kqlqueryset":
@@ -643,6 +1087,22 @@ class FabricClientCore(FabricClient):
         return response.status_code
 
     # List
+
+    def list_item_connections(self, workspace_id, item_id):
+        """List item connections
+        Args:
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+        Returns:
+            dict: The item connections
+        """
+        #GET https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/connections
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/connections"
+
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error listing item connections", return_format="value_json", paging=True)
+
+        return response_json
  
     def list_items(self, workspace_id, with_properties = False, type = None):
         """List items in a workspace
@@ -692,7 +1152,7 @@ class FabricClientCore(FabricClient):
                                     return_format="json+operation_result")
     
     
-    def update_item(self, workspace_id, item_id, display_name = None, description = None, type = None, return_item="Default"):
+    def update_item(self, workspace_id, item_id, display_name = None, description = None, type = None, return_item=False):
         """Update the item
         Args:
             workspace_id (str): The ID of the workspace
@@ -716,19 +1176,12 @@ class FabricClientCore(FabricClient):
         resp_dict = self.calling_routine(url, operation="PATCH", body=payload,
                                          response_codes=[200, 429], error_message="Error updating item",
                                          return_format="json")
-        if return_item == "Default":
-            warn(
-                message="Updating an item currently will make invoke an additional API call to get the item object. "
-                        "The default behaviour of returning the item object will change in newer versions of the SDK. "
-                        "To keep this behaviour, set return_item=True in the function call.",
-                category=FutureWarning,
-                stacklevel=2
-            )
+
         if return_item:
             return self.get_item_specific(workspace_id, resp_dict)
         return resp_dict
 
-    def update_item_definition(self, workspace_id, item_id, definition, type = None, wait_for_completion=True):
+    def update_item_definition(self, workspace_id, item_id, definition, type = None, wait_for_completion=True, **kwargs):
         """Update the item definition
         Args:
             workspace_id (str): The ID of the workspace
@@ -738,11 +1191,15 @@ class FabricClientCore(FabricClient):
         Returns:
             requests.Response: The response object
         """
+
         url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/updateDefinition"
 
         if type:
             url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/{type}/{item_id}/updateDefinition"
-            
+       
+        if "update_metadata" in kwargs and kwargs["update_metadata"]:
+            url = f"{url}?updateMetadata={kwargs['update_metadata']}"
+ 
         payload = {
             'definition': definition
         }
@@ -792,38 +1249,116 @@ class FabricClientCore(FabricClient):
         job_dict['itemId'] = item_id
         return JobInstance.from_dict(job_dict, core_client=self)
     
-
-    def run_on_demand_item_job(self, workspace_id, item_id, job_type, execution_data = None):
-        """Run an on demand job on the item
+    def create_item_schedule(self, workspace_id, item_id, job_type, configuration, enabled):
+        """Create a job schedule for the item
         Args:
             workspace_id (str): The ID of the workspace
             item_id (str): The ID of the item
             job_type (str): The type of the job
-            execution_data (dict): The execution data of the job
         Returns:
-            JobInstance: The job instance object
+            dict: The job schedule
         """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/{job_type}/schedules"
 
-        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/jobs/instances?jobType={jobType}
-        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/instances?jobType={job_type}"
-        payload = {
-            'executionData': execution_data
-        }
-
-        response = self.calling_routine(url, operation="POST", body=payload, response_codes=[202, 429],
-                                        error_message="Error running on demand job",
-                                        wait_for_completion=False, return_format="response")
+        payload = {"configuration": configuration,
+                   "enabled": enabled}
 
-        job_instance_id = response.headers["Location"].split("/")[-1]
-        job_instance = self.get_item_job_instance(workspace_id, item_id, job_instance_id=job_instance_id)
-        return job_instance
+        return self.calling_routine(url=url, operation="POST", body=payload, response_codes=[201, 429],
+                                    error_message="Error creating job schedule", return_format="json")
     
-    # long running operations
-
-    def get_operation_results(self, operation_id):
-        """Get the results of an operation
+    def get_item_schedule(self, workspace_id, item_id, job_type, schedule_id):
+        """Get the job schedule of the item
         Args:
-            operation_id (str): The ID of the operation
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+            job_type (str): The type of the job
+            schedule_id (str): The ID of the schedule
+        Returns:
+            dict: The job schedule
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/{job_type}/schedules/{schedule_id}"
+
+        return self.calling_routine(url=url, operation="GET", response_codes=[200, 429],
+                                    error_message="Error getting job schedule", return_format="json")
+    
+    def list_item_job_instances(self, workspace_id, item_id):
+        """List the job instances of the item
+        Args:
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+            job_type (str): The type of the job
+        Returns:
+            list: The list of job instances
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/instances"
+
+        return self.calling_routine(url=url, operation="GET", response_codes=[200, 429],
+                                    error_message="Error listing job instances", return_format="value_json", paging=True)
+    
+    def list_item_schedules(self, workspace_id, item_id, job_type):
+        """List the job schedules of the item
+        Args:
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+            job_type (str): The type of the job
+        Returns:
+            list: The list of job schedules
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/{job_type}/schedules"
+
+        return self.calling_routine(url=url, operation="GET", response_codes=[200, 429],
+                                    error_message="Error listing job schedules", return_format="value_json", paging=True)   
+
+    def run_on_demand_item_job(self, workspace_id, item_id, job_type, execution_data = None):
+        """Run an on demand job on the item
+        Args:
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+            job_type (str): The type of the job
+            execution_data (dict): The execution data of the job
+        Returns:
+            JobInstance: The job instance object
+        """
+
+        # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/items/{itemId}/jobs/instances?jobType={jobType}
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/instances?jobType={job_type}"
+        payload = {
+            'executionData': execution_data
+        }
+
+        response = self.calling_routine(url, operation="POST", body=payload, response_codes=[202, 429],
+                                        error_message="Error running on demand job",
+                                        wait_for_completion=False, return_format="response")
+
+        job_instance_id = response.headers["Location"].split("/")[-1]
+        job_instance = self.get_item_job_instance(workspace_id, item_id, job_instance_id=job_instance_id)
+        return job_instance
+    
+    def update_item_schedule(self, workspace_id, item_id, job_type, schedule_id, configuration, enabled):
+        """Update the job schedule of the item
+        Args:
+            workspace_id (str): The ID of the workspace
+            item_id (str): The ID of the item
+            job_type (str): The type of the job
+            schedule_id (str): The ID of the schedule
+            configuration (dict): The configuration of the schedule
+        Returns:
+            dict: The updated job schedule
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/items/{item_id}/jobs/{job_type}/schedules/{schedule_id}"
+
+        payload = {"configuration": configuration,
+                     "enabled": enabled}
+
+        return self.calling_routine(url=url, operation="PATCH", body=payload, response_codes=[200, 429],
+                                    error_message="Error updating job schedule", return_format="json")
+    
+    # long running operations
+
+    def get_operation_results(self, operation_id):
+        """Get the results of an operation
+        Args:
+            operation_id (str): The ID of the operation
         Returns:
             dict: The results of the operation
         """
@@ -850,6 +1385,82 @@ class FabricClientCore(FabricClient):
 
         return response_json
 
+    # Managed Private Endpoints:
+
+    def create_workspace_managed_private_endpoint(self, workspace_id, name, target_private_link_resource_id,
+                                                  target_subresource_type, request_message = None):
+        
+        """Create a managed private endpoint in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            name (str): The name of the managed private endpoint
+            target_private_link_resource_id (str): The target private link resource ID
+            target_subresource_type (str): The target subresource type
+            request_message (str): The request message
+        Returns:
+            dict: The created managed private endpoint
+        """
+
+        body = {
+            "name": name,
+            "targetPrivateLinkResourceId": target_private_link_resource_id,
+            "targetSubresourceType": target_subresource_type
+        }
+        if request_message:
+            body["requestMessage"] = request_message
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/managedPrivateEndpoints"
+
+        response = self.calling_routine(url, operation="POST", body=body,
+                                             response_codes=[201, 429], error_message="Error creating managed private endpoint",
+                                             return_format="json")
+
+        return response
+    
+    def delete_workspace_managed_private_endpoint(self, workspace_id, managed_private_endpoint_id):
+        """Delete a managed private endpoint in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            managed_private_endpoint_id (str): The ID of the managed private endpoint
+        Returns:
+            int: The status code of the response
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/managedPrivateEndpoints/{managed_private_endpoint_id}"
+
+        response = self.calling_routine(url, operation="DELETE", response_codes=[200, 429], return_format="response",
+                                             error_message="Error deleting managed private endpoint")
+
+        return response.status_code
+    
+    def get_workspace_managed_private_endpoint(self, workspace_id, managed_private_endpoint_id):
+        """Get a managed private endpoint in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            managed_private_endpoint_id (str): The ID of the managed private endpoint
+        Returns:
+            dict: The managed private endpoint
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/managedPrivateEndpoints/{managed_private_endpoint_id}"
+
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                             error_message="Error getting managed private endpoint", return_format="json")
+
+        return response_json
+    
+    def list_workspace_managed_private_endpoints(self, workspace_id):
+        """List managed private endpoints in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+        Returns:
+            list: The list of managed private endpoints
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/managedPrivateEndpoints"
+
+        response_json = self.calling_routine(url, operation="GET", response_codes=[200, 429], paging=True,
+                                             error_message="Error listing managed private endpoints", return_format="json")
+
+        return response_json
+
+
     # One Lake Data Access Security
 
     # create and update
@@ -985,6 +1596,24 @@ class FabricClientCore(FabricClient):
             shortcut['itemId'] = item_id
         return [OneLakeShortcut.from_dict(shortcut, core_client=self) for shortcut in shortcuts]
     
+
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/onelake/resetShortcutCache
+    def reset_shortcut_cache(self, workspace_id, wait_for_completion = False):
+        """Reset the shortcut cache
+
+        Args:
+            workspace_id (str): The ID of the workspace
+
+        Returns:
+            int: The status code of the response
+        """
+
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/onelake/resetShortcutCache"
+        response = self.calling_routine(url=url, operation="POST", response_codes=[200, 202, 429], error_message="Error resetting shortcut cache",
+                                        return_format="response", wait_for_completion = wait_for_completion)
+
+        return response.status_code
+
     ### Workspaces
 
     def add_workspace_role_assignment(self, workspace_id, role, principal):
@@ -1274,10 +1903,6 @@ class FabricClientCore(FabricClient):
     def list_datamarts(self, workspace_id):
         """List datamarts in a workspace"""
         return self.list_items(workspace_id, type="datamarts")
-    
-    def list_paginated_reports(self, workspace_id):
-        """List paginated reports in a workspace"""
-        return self.list_items(workspace_id, type="paginatedReports")
 
     def list_sql_endpoints(self, workspace_id):
         """List sql endpoints in a workspace"""
@@ -1346,7 +1971,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id, type="dataPipelines", with_properties=with_properties)
     
-    def update_data_pipeline(self, workspace_id, data_pipeline_id, display_name = None, description = None, return_item="Default"):
+    def update_data_pipeline(self, workspace_id, data_pipeline_id, display_name = None, description = None, return_item=False):
         """Update a data pipeline in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1422,7 +2047,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id, type="environments", with_properties=with_properties)
     
-    def update_environment(self, workspace_id, environment_id, display_name = None, description = None, return_item="Default"):
+    def update_environment(self, workspace_id, environment_id, display_name = None, description = None, return_item=False):
         """Update an environment in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1644,8 +2269,23 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                          error_message="Error getting eventhouse", return_format="json")
-        return Eventhouse.from_dict(item_dict, core_client=self)
+        ev = Eventhouse.from_dict(item_dict, core_client=self)
+        ev.get_definition()
+        return ev
     
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/eventhouses/{eventhouseId}/getDefinition
+
+    def get_eventhouse_definition(self, workspace_id, eventhouse_id, format = None):
+        """Get the definition of an eventhouse
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventhouse_id (str): The ID of the eventhouse
+            format (str): The format of the definition
+        Returns:
+            dict: The eventhouse definition
+        """
+        return self.get_item_definition(workspace_id, eventhouse_id, type="eventhouses", format=format)
+
     def list_eventhouses(self, workspace_id, with_properties = False):
         """List eventhouses in a workspace
         Args:
@@ -1656,7 +2296,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id=workspace_id, type="eventhouses", with_properties=with_properties)
     
-    def update_eventhouse(self, workspace_id, eventhouse_id, display_name = None, description = None, return_item="Default"):
+    def update_eventhouse(self, workspace_id, eventhouse_id, display_name = None, description = None, return_item=False):
         """Update an eventhouse in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1669,6 +2309,19 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id=workspace_id, item_id=eventhouse_id,
                                 display_name=display_name, description=description, type="eventhouses", return_item=return_item)
 
+    def update_eventhouse_definition(self, workspace_id, eventhouse_id, definition, update_metadata = None):
+        """Update the definition of an eventhouse
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventhouse_id (str): The ID of the eventhouse
+            definition (dict): The definition of the eventhouse
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated eventhouse definition
+        """
+        return self.update_item_definition(workspace_id, eventhouse_id, type="eventhouses", definition=definition, update_metadata=update_metadata)
+
+
     # eventstreams
 
     def create_eventstream(self, workspace_id, display_name, description = None):
@@ -1710,8 +2363,24 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                             error_message="Error getting eventstream", return_format="json")
-        return Eventstream.from_dict(item_dict, core_client=self)
+        es = Eventstream.from_dict(item_dict, core_client=self)
+        es.get_definition()
+        return es
     
+    def get_eventstream_definition(self, workspace_id, eventstream_id, format = None):
+        """Get the definition of an eventstream
+
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventstream_id (str): The ID of the eventstream
+            format (str): The format of the definition
+        Returns:
+            dict: The eventstream definition
+        """
+
+        return self.get_item_definition(workspace_id, eventstream_id, type="eventstreams", format=format)
+
+
     def delete_eventstream(self, workspace_id, eventstream_id):
         """Delete an eventstream from a workspace
         Args:
@@ -1732,7 +2401,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id=workspace_id, type="eventstreams", with_properties=with_properties)
 
-    def update_eventstream(self, workspace_id, eventstream_id, display_name = None, description = None, return_item="Default"):
+    def update_eventstream(self, workspace_id, eventstream_id, display_name = None, description = None, return_item=False):
         """Update an eventstream in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1744,6 +2413,194 @@ class FabricClientCore(FabricClient):
         """
         return self.update_item(workspace_id, eventstream_id, display_name = display_name, description = description, 
                                 type= "eventstreams", return_item=return_item)
+    
+    def update_eventstream_definition(self, workspace_id, eventstream_id, definition, update_metadata = None):
+        """Update the definition of an eventstream
+        Args:
+            workspace_id (str): The ID of the workspace
+            eventstream_id (str): The ID of the eventstream
+            definition (dict): The definition of the eventstream
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated definition of the eventstream
+        """
+        return self.update_item_definition(workspace_id, eventstream_id, type="eventstreams", definition=definition, update_metadata=update_metadata)
+
+    # graphqlapis
+
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/GraphQLApis
+    def create_graphql_api(self, workspace_id, display_name, description = None):
+        """Create a graphql api in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the graphql api
+            description (str): The description of the graphql api
+        Returns:
+            dict: The created graphql api
+        """
+        return self.create_item(workspace_id = workspace_id,
+                                display_name = display_name,
+                                type = "GraphQLApis",
+                                description = description)
+    
+    def delete_graphql_api(self, workspace_id, graphql_api_id):
+        """Delete a graphql api from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, graphql_api_id, type="GraphQLApis")
+    
+    def get_graphql_api(self, workspace_id, graphql_api_id = None, graphql_api_name = None):
+        """Get a graphql api from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+            graphql_api_name (str): The name of the graphql api
+        Returns:
+            dict: The graphql api
+        """
+        from msfabricpysdkcore.otheritems import GraphQLApi
+        if graphql_api_id is None and graphql_api_name is not None:
+            graphql_apis = self.list_graphql_apis(workspace_id)
+            graphql_apis = [ga for ga in graphql_apis if ga.display_name == graphql_api_name]
+            if len(graphql_apis) == 0:
+                raise Exception(f"Graphql api with name {graphql_api_name} not found")
+            graphql_api_id = graphql_apis[0].id
+        if graphql_api_id is None:
+            raise Exception("graphql_api_id or the graphql_api_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/GraphQLApis/{graphql_api_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting graphql api", return_format="json")
+        graphql = GraphQLApi.from_dict(item_dict, core_client=self)
+        return graphql
+    
+    def list_graphql_apis(self, workspace_id, with_properties = False):
+        """List graphql apis in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of graphql apis
+        """
+        return self.list_items(workspace_id=workspace_id, type="GraphQLApis", with_properties=with_properties)
+
+    def update_graphql_api(self, workspace_id, graphql_api_id, display_name = None, description = None, return_item=False):
+        """Update a graphql api in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            graphql_api_id (str): The ID of the graphql api
+            display_name (str): The display name of the graphql api
+            description (str): The description of the graphql api
+        Returns:
+            dict: The updated graphql api
+        """
+        return self.update_item(workspace_id, graphql_api_id, display_name = display_name, description = description, 
+                                type= "GraphQLApis", return_item=return_item)
+
+    # kqlDashboard
+    def create_kql_dashboard(self, workspace_id, display_name, description = None):
+        """Create a kql dashboard in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the kql dashboard
+            description (str): The description of the kql dashboard
+        Returns:
+            dict: The created kql dashboard
+        """
+        return self.create_item(workspace_id = workspace_id,
+                                display_name = display_name,
+                                type = "kqlDashboards",
+                                description = description)
+    
+    def delete_kql_dashboard(self, workspace_id, kql_dashboard_id):
+        """Delete a kql dashboard from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_dashboard_id (str): The ID of the kql dashboard
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, kql_dashboard_id, type="kqlDashboards")
+    
+    def get_kql_dashboard(self, workspace_id, kql_dashboard_id = None, kql_dashboard_name = None):
+        """Get a kql dashboard from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_dashboard_id (str): The ID of the kql dashboard
+            kql_dashboard_name (str): The name of the kql dashboard
+        Returns:
+            KQLDashboard: The kql dashboard object
+        """
+        
+        from msfabricpysdkcore.otheritems import KQLDashboard
+        if kql_dashboard_id is None and kql_dashboard_name is not None:
+            kql_dashboards = self.list_kql_dashboards(workspace_id)
+            kql_dashboards = [kd for kd in kql_dashboards if kd.display_name == kql_dashboard_name]
+            if len(kql_dashboards) == 0:
+                raise Exception(f"Kql dashboard with name {kql_dashboard_name} not found")
+            kql_dashboard_id = kql_dashboards[0].id
+        if kql_dashboard_id is None:
+            raise Exception("kql_dashboard_id or the kql_dashboard_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/kqlDashboards/{kql_dashboard_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                            error_message="Error getting kql dashboard", return_format="json")
+        kqldashboard = KQLDashboard.from_dict(item_dict, core_client=self)
+        kqldashboard.get_definition()
+        return kqldashboard
+
+    def get_kql_dashboard_definition(self, workspace_id, kql_dashboard_id, format=None):
+        """Get the definition of a kql dashboard
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_dashboard_id (str): The ID of the kql dashboard
+        Returns:
+            dict: The definition of the kql dashboard
+        """
+        return self.get_item_definition(workspace_id, kql_dashboard_id, type="kqlDashboards", format=format)
+
+
+    def list_kql_dashboards(self, workspace_id, with_properties = False):
+        """List kql dashboards in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of kql dashboards
+        """
+        return self.list_items(workspace_id=workspace_id, type="kqlDashboards", with_properties=with_properties)
+    
+    def update_kql_dashboard(self, workspace_id, kql_dashboard_id, display_name = None, description = None, return_item=False):
+        """Update a kql dashboard in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_dashboard_id (str): The ID of the kql dashboard
+            display_name (str): The display name of the kql dashboard
+            description (str): The description of the kql dashboard
+        Returns:
+            dict: The updated kql dashboard
+        """
+        return self.update_item(workspace_id, kql_dashboard_id, display_name = display_name,
+                                description = description, type= "kqlDashboards", return_item=return_item)
+    
+    def update_kql_dashboard_definition(self, workspace_id, kql_dashboard_id, definition, update_metadata = None):
+        """Update the definition of a kql dashboard
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_dashboard_id (str): The ID of the kql dashboard
+            definition (dict): The definition of the kql dashboard
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated definition of the kql dashboard
+        """
+        return self.update_item_definition(workspace_id, kql_dashboard_id,
+                                           type="kqlDashboards", definition=definition, update_metadata=update_metadata)
 
     # kqlDatabases
 
@@ -1796,7 +2653,20 @@ class FabricClientCore(FabricClient):
 
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                          error_message="Error getting kql database", return_format="json")
-        return KQLDatabase.from_dict(item_dict, core_client=self)
+        kqldb = KQLDatabase.from_dict(item_dict, core_client=self)
+        kqldb.get_definition()
+        return kqldb
+    
+    def get_kql_database_definition(self, workspace_id, kql_database_id, format=None):
+        """Get the definition of a kql database
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_database_id (str): The ID of the kql database
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the kql database
+        """
+        return self.get_item_definition(workspace_id, kql_database_id, type="kqlDatabases", format=format)
 
     def list_kql_databases(self, workspace_id, with_properties = False):
         """List kql databases in a workspace
@@ -1807,7 +2677,7 @@ class FabricClientCore(FabricClient):
             list: The list of kql databases"""
         return self.list_items(workspace_id=workspace_id, type="kqlDatabases", with_properties=with_properties)
     
-    def update_kql_database(self, workspace_id, kql_database_id, display_name = None, description = None, return_item="Default"):
+    def update_kql_database(self, workspace_id, kql_database_id, display_name = None, description = None, return_item=False):
         """Update a kql database in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1820,8 +2690,38 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id, kql_database_id, display_name = display_name,
                                 description = description, type= "kqlDatabases", return_item=return_item)
 
+    def update_kql_database_definition(self, workspace_id, kql_database_id, definition, update_metadata = None):
+        """Update the definition of a kql database
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_database_id (str): The ID of the kql database
+            definition (dict): The definition of the kql database
+            update_metadata (bool): Whether to update the metadata
+        Returns:
+            dict: The updated definition of the kql database
+        """
+        return self.update_item_definition(workspace_id, kql_database_id,
+                                           type="kqlDatabases", definition=definition, update_metadata=update_metadata)
+
     # kqlQuerysets
 
+    def create_kql_queryset(self, workspace_id, display_name, description = None, definition = None):
+        """Create a kql queryset in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the kql queryset
+            description (str): The description of the kql queryset
+            definition (dict): The definition of the kql queryset
+        Returns:
+            dict: The created kql queryset
+        """
+        return self.create_item(workspace_id = workspace_id,
+                                display_name = display_name,
+                                type = "kqlQuerysets",
+                                description = description,
+                                definition = definition)
+
+
         
     def delete_kql_queryset(self, workspace_id, kql_queryset_id):
         """Delete a kql queryset from a workspace
@@ -1857,9 +2757,31 @@ class FabricClientCore(FabricClient):
         item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
                                          error_message="Error getting kql queryset", return_format="json")
         
-        return KQLQueryset.from_dict(item_dict, core_client=self)
+        kql =  KQLQueryset.from_dict(item_dict, core_client=self)
+        kql.get_definition()
+        return kql
+    
+    def get_kql_queryset_definition(self, workspace_id, kql_queryset_id, format=None):
+        """Get the definition of a kql queryset
+        Args:
+            workspace_id (str): The ID of the workspace
+            kql_queryset_id (str): The ID of the kql queryset
+        Returns:
+            dict: The definition of the kql queryset
+        """
+        return self.get_item_definition(workspace_id, kql_queryset_id, type="kqlQuerysets", format=format)
 
-    def update_kql_queryset(self, workspace_id, kql_queryset_id, display_name = None, description = None, return_item="Default"):
+    def list_kql_querysets(self, workspace_id, with_properties = False):
+        """List kql querysets in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of kql querysets
+        """
+        return self.list_items(workspace_id=workspace_id, type="kqlQuerysets", with_properties=with_properties)
+    
+    def update_kql_queryset(self, workspace_id, kql_queryset_id, display_name = None, description = None, return_item=False):
         """Update a kql queryset in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -1872,15 +2794,18 @@ class FabricClientCore(FabricClient):
         return self.update_item(workspace_id, kql_queryset_id, display_name = display_name,
                                 description = description, type= "kqlQuerysets", return_item=return_item)
 
-    def list_kql_querysets(self, workspace_id, with_properties = False):
-        """List kql querysets in a workspace
+    def update_kql_queryset_definition(self, workspace_id, kql_queryset_id, definition, update_metadata = None):
+        """Update the definition of a kql queryset
         Args:
             workspace_id (str): The ID of the workspace
-            with_properties (bool): Whether to get the item object with properties
+            kql_queryset_id (str): The ID of the kql queryset
+            definition (dict): The definition of the kql queryset
+            update_metadata (bool): Whether to update the metadata
         Returns:
-            list: The list of kql querysets
+            dict: The updated definition of the kql queryset
         """
-        return self.list_items(workspace_id=workspace_id, type="kqlQuerysets", with_properties=with_properties)
+        return self.update_item_definition(workspace_id, kql_queryset_id,
+                                           type="kqlQuerysets", definition=definition, update_metadata=update_metadata)
 
 
     # lakehouses
@@ -1969,7 +2894,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id, type="lakehouses", with_properties = with_properties)
 
-    def update_lakehouse(self, workspace_id, lakehouse_id, display_name = None, description = None, return_item="Default"):
+    def update_lakehouse(self, workspace_id, lakehouse_id, display_name = None, description = None, return_item=False):
         """Update a lakehouse in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -2065,8 +2990,161 @@ class FabricClientCore(FabricClient):
             self._logger.info("Table created")
         return response.status_code
 
-    # mlExperiments
+    # mirrored_database
+
+    def create_mirrored_database(self, workspace_id, display_name, description = None, definition = None):
+        """Create a mirrored database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the mirrored database
+            description (str): The description of the mirrored database
+        Returns:
+            dict: The created mirrored database
+        """
+        return self.create_item(workspace_id = workspace_id,
+                                display_name = display_name,
+                                type = "mirroredDatabases",
+                                description = description,
+                                definition=definition)
+    
+    def delete_mirrored_database(self, workspace_id, mirrored_database_id):
+        """Delete a mirrored database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, mirrored_database_id, type="mirroredDatabases")
+    
+    def get_mirrored_database(self, workspace_id, mirrored_database_id = None, mirrored_database_name = None):
+        """Get a mirrored database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+            mirrored_database_name (str): The name of the mirrored database
+        Returns:
+            MirroredDatabase: The mirrored database object
+        """
+        from msfabricpysdkcore.otheritems import MirroredDatabase
+
+        if mirrored_database_id is None and mirrored_database_name is not None:
+            mirrored_databases = self.list_mirrored_databases(workspace_id)
+            mirrored_databases = [md for md in mirrored_databases if md.display_name == mirrored_database_name]
+            if len(mirrored_databases) == 0:
+                raise Exception(f"Mirrored database with name {mirrored_database_name} not found")
+            mirrored_database_id = mirrored_databases[0].id
+        
+        if mirrored_database_id is None:
+            raise Exception("mirrored_database_id or the mirrored_database_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mirroredDatabases/{mirrored_database_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                            error_message="Error getting mirrored database", return_format="json")
+        mirrored_db = MirroredDatabase.from_dict(item_dict, core_client=self)
+        return mirrored_db
+
+    def get_mirrored_database_definition(self, workspace_id, mirrored_database_id):
+        """Get the definition of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            dict: The definition of the mirrored database
+        """
+        return self.get_item_definition(workspace_id, mirrored_database_id, type="mirroredDatabases")
+
+    def list_mirrored_databases(self, workspace_id, with_properties = False):
+        """List mirrored databases in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of mirrored databases
+        """
+        return self.list_items(workspace_id=workspace_id, type="mirroredDatabases", with_properties=with_properties)
+    
+    def update_mirrored_database(self, workspace_id, mirrored_database_id, display_name = None, description = None, return_item=False): 
+        """Update a mirrored database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+            display_name (str): The display name of the mirrored database
+            description (str): The description of the mirrored database
+        Returns:
+            dict: The updated mirrored database
+        """
+        return self.update_item(workspace_id, mirrored_database_id, display_name = display_name, description = description,
+                                type="mirroredDatabases", return_item=return_item)
+    
+    def update_mirrored_database_definition(self, workspace_id, mirrored_database_id, definition):
+        """Update the definition of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+            definition (dict): The definition of the mirrored database
+        Returns:
+            dict: The updated definition of the mirrored database
+        """
+        return self.update_item_definition(workspace_id, mirrored_database_id,
+                                           type="mirroredDatabases", definition=definition)
+    
+    
+    def get_mirroring_status(self, workspace_id, mirrored_database_id):
+        """Get the mirroring status of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            dict: The mirroring status of the mirrored database
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mirroredDatabases/{mirrored_database_id}/getMirroringStatus"
+
+        return self.calling_routine(url, operation="POST", response_codes=[200, 429],
+                                    error_message="Error getting mirroring status", return_format="json")
+
+    def get_tables_mirroring_status(self, workspace_id, mirrored_database_id):
+        """Get the tables mirroring status of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            dict: The tables mirroring status of the mirrored database
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mirroredDatabases/{mirrored_database_id}/getTablesMirroringStatus"
 
+        return self.calling_routine(url, operation="POST", response_codes=[200, 429],
+                                    error_message="Error getting tables mirroring status", return_format="json")
+
+    def start_mirroring(self, workspace_id, mirrored_database_id):
+        """Start mirroring of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            dict: The operation result
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mirroredDatabases/{mirrored_database_id}/startMirroring"
+
+        return self.calling_routine(url, operation="POST", response_codes=[200, 429],
+                                    error_message="Error starting mirroring", return_format="response")
+    
+    def stop_mirroring(self, workspace_id, mirrored_database_id):
+        """Stop mirroring of a mirrored database
+        Args:
+            workspace_id (str): The ID of the workspace
+            mirrored_database_id (str): The ID of the mirrored database
+        Returns:
+            dict: The operation result
+        """
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mirroredDatabases/{mirrored_database_id}/stopMirroring"
+
+        return self.calling_routine(url, operation="POST", response_codes=[200, 429],
+                                    error_message="Error stopping mirroring", return_format="response")
+
+
+    # mlExperiments
 
     def create_ml_experiment(self, workspace_id, display_name, description = None):
         """Create an ml experiment in a workspace
@@ -2127,7 +3205,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id=workspace_id, type="mlExperiments", with_properties = with_properties)
     
-    def update_ml_experiment(self, workspace_id, ml_experiment_id, display_name = None, description = None, return_item="Default"):
+    def update_ml_experiment(self, workspace_id, ml_experiment_id, display_name = None, description = None, return_item=False):
         """Update an ml experiment in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -2200,7 +3278,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id=workspace_id, type="mlModels", with_properties = with_properties)
     
-    def update_ml_model(self, workspace_id, ml_model_id, display_name = None, description = None, return_item="Default"):
+    def update_ml_model(self, workspace_id, ml_model_id, display_name = None, description = None, return_item=False):
         """Update an ml model in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -2212,7 +3290,106 @@ class FabricClientCore(FabricClient):
         """
         return self.update_item(workspace_id, ml_model_id, display_name = display_name, description = description,
                                 type="mlModels", return_item=return_item)
+
+    # mounted data factory
+    # POST https://api.fabric.microsoft.com/v1/workspaces/{workspaceId}/mountedDataFactories
+
+    def create_mounted_data_factory(self, workspace_id, display_name, description = None, definition = None):
+        """Create a mounted data factory in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the mounted data factory
+            description (str): The description of the mounted data factory
+            definition (dict): The definition of the mounted data factory
+        Returns:
+            dict: The created mounted data factory
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "mountedDataFactories",
+                                description = description, definition = definition)
+    
+    def delete_mounted_data_factory(self, workspace_id, mounted_data_factory_id):
+        """Delete a mounted data factory from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, mounted_data_factory_id, type="mountedDataFactories")
+
+    def get_mounted_data_factory(self, workspace_id, mounted_data_factory_id = None, mounted_data_factory_name = None):
+        """Get a mounted data factory from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            mounted_data_factory_name (str): The name of the mounted data factory
+        Returns:
+            MountedDataFactory: The mounted data factory object
+        """
+        from msfabricpysdkcore.otheritems import MountedDataFactory
+        if mounted_data_factory_id is None and mounted_data_factory_name is not None:
+            mounted_data_factories = self.list_mounted_data_factories(workspace_id)
+            mounted_data_factories = [mdf for mdf in mounted_data_factories if mdf.display_name == mounted_data_factory_name]
+            if len(mounted_data_factories) == 0:
+                raise Exception(f"Mounted data factory with name {mounted_data_factory_name} not found")
+            mounted_data_factory_id = mounted_data_factories[0].id
+        if mounted_data_factory_id is None:
+            raise Exception("mounted_data_factory_id or the mounted_data_factory_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/mountedDataFactories/{mounted_data_factory_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting mounted data factory", return_format="json")
+        
+        mdf = MountedDataFactory.from_dict(item_dict, core_client=self)
+        mdf.get_definition()
+        return mdf
     
+    def get_mounted_data_factory_definition(self, workspace_id, mounted_data_factory_id, format = None):
+        """Get the definition of a mounted data factory
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the mounted data factory
+        """
+        return self.get_item_definition(workspace_id, mounted_data_factory_id, type="mountedDataFactories", format=format)
+
+    def list_mounted_data_factories(self, workspace_id, with_properties = False):
+        """List mounted data factories in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of mounted data factories
+        """
+        return self.list_items(workspace_id=workspace_id, type="mountedDataFactories", with_properties = with_properties)
+    
+    def update_mounted_data_factory(self, workspace_id, mounted_data_factory_id, display_name = None, description = None, return_item=False):
+        """Update a mounted data factory in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            display_name (str): The display name of the mounted data factory
+            description (str): The description of the mounted data factory
+        Returns:
+            dict: The updated mounted data factory
+        """
+        return self.update_item(workspace_id, mounted_data_factory_id, display_name = display_name, description = description,
+                                type="mountedDataFactories", return_item=return_item)
+
+    def update_mounted_data_factory_definition(self, workspace_id, mounted_data_factory_id, definition, update_metadata = None):
+        """Update the definition of a mounted data factory
+        Args:
+            workspace_id (str): The ID of the workspace
+            mounted_data_factory_id (str): The ID of the mounted data factory
+            definition (dict): The definition of the mounted data factory
+        Returns:
+            dict: The updated definition of the mounted data factory
+        """
+        return self.update_item_definition(workspace_id, mounted_data_factory_id, definition, type="mountedDataFactories", update_metadata=update_metadata)
+
     # notebooks
 
     def create_notebook(self, workspace_id, display_name, definition = None, description = None):
@@ -2286,7 +3463,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id = workspace_id, type = "notebooks", with_properties = with_properties)
     
-    def update_notebook(self, workspace_id, notebook_id, display_name = None, description = None, return_item="Default"):
+    def update_notebook(self, workspace_id, notebook_id, display_name = None, description = None, return_item=False):
         """Update a notebook in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -2310,6 +3487,122 @@ class FabricClientCore(FabricClient):
         """
         return self.update_item_definition(workspace_id, notebook_id, definition, type="notebooks")
     
+    # paginatedReports
+
+    def list_paginated_reports(self, workspace_id):
+        """List paginated reports in a workspace"""
+        return self.list_items(workspace_id, type="paginatedReports")
+    
+    def update_paginated_report(self, workspace_id, paginated_report_id, display_name = None, description = None, return_item=False):
+        """Update a paginated report in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            paginated_report_id (str): The ID of the paginated report
+            display_name (str): The display name of the paginated report
+            description (str): The description of the paginated report
+        Returns:
+            dict: The updated paginated report
+        """
+        return self.update_item(workspace_id, paginated_report_id, display_name = display_name, description = description,
+                                type="paginatedReports", return_item=return_item)
+
+    # reflex
+
+    def create_reflex(self, workspace_id, display_name, description = None, definition = None):
+        """Create a reflex in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the reflex
+            description (str): The description of the reflex
+            definition (dict): The definition of the reflex
+        Returns:
+            dict: The created reflex
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "reflexes", description = description, definition = definition)
+
+    def delete_reflex(self, workspace_id, reflex_id):
+        """Delete a reflex from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, reflex_id, type="reflexes")
+    
+    def get_reflex(self, workspace_id, reflex_id = None, reflex_name = None):
+        """Get a reflex from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            reflex_name (str): The name of the reflex
+        Returns:
+            Reflex: The reflex object
+        """
+        from msfabricpysdkcore.otheritems import Reflex
+        if reflex_id is None and reflex_name is not None:
+            reflexes = self.list_reflexes(workspace_id)
+            reflexes = [rf for rf in reflexes if rf.display_name == reflex_name]
+            if len(reflexes) == 0:
+                raise Exception(f"Reflex with name {reflex_name} not found")
+            reflex_id = reflexes[0].id
+        if reflex_id is None:
+            raise Exception("reflex_id or the reflex_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/reflexes/{reflex_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting reflex", return_format="json")
+        
+        refl = Reflex.from_dict(item_dict, core_client=self)
+        refl.get_definition()
+        return refl
+    
+    def get_reflex_definition(self, workspace_id, reflex_id, format = None):
+        """Get the definition of a reflex
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            format (str): The format of the definition
+        Returns:
+            dict: The definition of the reflex
+        """
+        return self.get_item_definition(workspace_id, reflex_id, type="reflexes", format=format)
+
+    def list_reflexes(self, workspace_id, with_properties = False):
+        """List reflexes in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of reflexes
+        """
+        return self.list_items(workspace_id = workspace_id, type = "reflexes", with_properties = with_properties)
+    
+    def update_reflex(self, workspace_id, reflex_id, display_name = None, description = None, return_item=False):
+        """Update a reflex in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            display_name (str): The display name of the reflex
+            description (str): The description of the reflex
+        Returns:
+            dict: The updated reflex
+        """
+        return self.update_item(workspace_id, reflex_id, display_name = display_name, description = description,
+                                type="reflexes", return_item=return_item)
+    
+    def update_reflex_definition(self, workspace_id, reflex_id, definition, update_metadata = None):
+        """Update the definition of a reflex
+        Args:
+            workspace_id (str): The ID of the workspace
+            reflex_id (str): The ID of the reflex
+            definition (dict): The definition of the reflex
+        Returns:
+            dict: The updated reflex
+        """
+        return self.update_item_definition(workspace_id, reflex_id, definition, type="reflexes", update_metadata=update_metadata)
+    
     # reports
 
     def create_report(self, workspace_id, display_name, definition = None, description = None):
@@ -2384,6 +3677,19 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id = workspace_id, type = "reports", with_properties = with_properties)
 
+    def update_report(self, workspace_id, report_id, display_name = None, description = None, return_item=False):
+        """Update a report in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            report_id (str): The ID of the report
+            display_name (str): The display name of the report
+            description (str): The description of the report
+        Returns:
+            dict: The updated report
+        """
+        return self.update_item(workspace_id, report_id, display_name = display_name, description = description,
+                                type="reports", return_item=return_item)
+
     def update_report_definition(self, workspace_id, report_id, definition):
         """Update the definition of a report
         Args:
@@ -2397,16 +3703,6 @@ class FabricClientCore(FabricClient):
 
     # semanticModels
 
-    def list_semantic_models(self, workspace_id, with_properties = False):
-        """List semantic models in a workspace
-        Args:
-            workspace_id (str): The ID of the workspace
-            with_properties (bool): Whether to get the item object with properties
-        Returns:
-            list: The list of semantic models
-        """
-        return self.list_items(workspace_id = workspace_id, type = "semanticModels", with_properties = with_properties)
-    
     def create_semantic_model(self, workspace_id, display_name, definition = None, description = None):
         """Create a semantic model in a workspace
         Args:
@@ -2418,6 +3714,16 @@ class FabricClientCore(FabricClient):
             dict: The created semantic model
         """
         return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "semanticModels", definition = definition, description = description)
+
+    def delete_semantic_model(self, workspace_id, semantic_model_id):
+        """Delete a semantic model from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            semantic_model_id (str): The ID of the semantic model
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, semantic_model_id, type="semanticModels")
     
     def get_semantic_model(self, workspace_id, semantic_model_id = None, semantic_model_name = None):
         """Get a semantic model from a workspace
@@ -2447,31 +3753,39 @@ class FabricClientCore(FabricClient):
 
         return semmodel
     
-    def delete_semantic_model(self, workspace_id, semantic_model_id):
-        """Delete a semantic model from a workspace
+    def get_semantic_model_definition(self, workspace_id, semantic_model_id, format = None):
+        """Get the definition of a semantic model
         Args:
             workspace_id (str): The ID of the workspace
             semantic_model_id (str): The ID of the semantic model
+            format (str): The format of the definition
         Returns:
-            int: The status code of the response
+            dict: The definition of the semantic model
         """
-        return self.delete_item(workspace_id, semantic_model_id, type="semanticModels")
+        return self.get_item_definition(workspace_id, semantic_model_id, type="semanticModels", format=format)
     
-    # def update_semantic_model(self, workspace_id, semantic_model_id, display_name = None, description = None):
-    #     """Update a semantic model in a workspace"""
-    #     ws = self.get_workspace_by_id(workspace_id)
-    #     return ws.update_semantic_model(semantic_model_id, display_name = display_name, description = description)
+    def list_semantic_models(self, workspace_id, with_properties = False):
+        """List semantic models in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of semantic models
+        """
+        return self.list_items(workspace_id = workspace_id, type = "semanticModels", with_properties = with_properties)
     
-    def get_semantic_model_definition(self, workspace_id, semantic_model_id, format = None):
-        """Get the definition of a semantic model
+    def update_semantic_model(self, workspace_id, semantic_model_id, display_name = None, description = None, return_item=False):
+        """Update a semantic model in a workspace
         Args:
             workspace_id (str): The ID of the workspace
             semantic_model_id (str): The ID of the semantic model
-            format (str): The format of the definition
+            display_name (str): The display name of the semantic model
+            description (str): The description of the semantic model
         Returns:
-            dict: The definition of the semantic model
+            dict: The updated semantic model
         """
-        return self.get_item_definition(workspace_id, semantic_model_id, type="semanticModels", format=format)
+        return self.update_item(workspace_id, semantic_model_id, display_name = display_name, description = description,
+                                type="semanticModels", return_item=return_item)
 
     def update_semantic_model_definition(self, workspace_id, semantic_model_id, definition):
         """Update the definition of a semantic model
@@ -2483,6 +3797,7 @@ class FabricClientCore(FabricClient):
             dict: The updated semantic model
         """
         return self.update_item_definition(workspace_id, semantic_model_id, definition, type="semanticModels", wait_for_completion=False)
+    
     # spark workspace custom pools
 
     def create_workspace_custom_pool(self, workspace_id, name, node_family, node_size, auto_scale, dynamic_executor_allocation):
@@ -2566,7 +3881,7 @@ class FabricClientCore(FabricClient):
         return sppools
     
     def update_workspace_custom_pool(self, workspace_id, pool_id, name = None, node_family = None, node_size = None, auto_scale = None, dynamic_executor_allocation = None,
-                                     return_item = "Default"):
+                                     return_item = False):
         """Update a workspace custom pool
         Args:
             workspace_id (str): The ID of the workspace
@@ -2600,14 +3915,6 @@ class FabricClientCore(FabricClient):
         response_json = self.calling_routine(url, operation="PATCH", body=body, response_codes=[200, 429],
                                              error_message="Error updating workspace custom pool", return_format="json")
 
-        if return_item == "Default":
-            warn(
-                message="Warning: Updating an item currently will make invoke an additional API call to get the item "
-                        "object. This default behaviour will change in newer versions of the SDK. To keep this "
-                        "behaviour, set return_item=True in the function call.",
-                category=FutureWarning,
-                stacklevel=2
-            )
         if return_item:
             return self.get_workspace_custom_pool(workspace_id, pool_id)
         return response_json
@@ -2721,7 +4028,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id = workspace_id, type = "sparkJobDefinitions", with_properties = with_properties)
     
-    def update_spark_job_definition(self, workspace_id, spark_job_definition_id, display_name = None, description = None, return_item="Default"):
+    def update_spark_job_definition(self, workspace_id, spark_job_definition_id, display_name = None, description = None, return_item=False):
         """Update a spark job definition in a workspace
         Args:
             workspace_id (str): The ID of the workspace
@@ -2744,7 +4051,7 @@ class FabricClientCore(FabricClient):
             dict: The definition of the spark job definition
         """
         return self.get_item_definition(workspace_id, spark_job_definition_id, type="sparkJobDefinitions", format=format)
-
+    
     def update_spark_job_definition_definition(self, workspace_id, spark_job_definition_id, definition):
         """Update the definition of a spark job definition
         Args:
@@ -2777,7 +4084,80 @@ class FabricClientCore(FabricClient):
                                           item_id = spark_job_definition_id,
                                           job_instance_id = job_instance_id)
 
+    # sql database
+
+    def create_sql_database(self, workspace_id, display_name, description = None, definition = None):
+        """Create a SQL database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            display_name (str): The display name of the SQL database
+            description (str): The description of the SQL database
+            definition (dict): The definition of the SQL database
+        Returns:
+            dict: The created SQL database
+        """
+        return self.create_item(workspace_id = workspace_id, display_name = display_name, type = "SQLDatabases", definition = definition, description = description)
+    
+    def delete_sql_database(self, workspace_id, sql_database_id):
+        """Delete a SQL database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+        Returns:
+            int: The status code of the response
+        """
+        return self.delete_item(workspace_id, sql_database_id, type="SQLDatabases")
     
+    def get_sql_database(self, workspace_id, sql_database_id = None, sql_database_name = None):
+        """Get a SQL database from a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+            sql_database_name (str): The name of the SQL database
+        Returns:
+            SQLDatabase: The SQL database object
+        """
+        from msfabricpysdkcore.otheritems import SQLDatabase
+        if sql_database_id is None and sql_database_name is not None:
+            sql_databases = self.list_sql_databases(workspace_id)
+            sql_databases = [sd for sd in sql_databases if sd.display_name == sql_database_name]
+            if len(sql_databases) == 0:
+                raise Exception(f"SQL database with name {sql_database_name} not found")
+            sql_database_id = sql_databases[0].id
+        elif sql_database_id is None:
+            raise Exception("sql_database_id or the sql_database_name is required")
+        
+        url = f"https://api.fabric.microsoft.com/v1/workspaces/{workspace_id}/SQLDatabases/{sql_database_id}"
+
+        item_dict = self.calling_routine(url, operation="GET", response_codes=[200, 429],
+                                         error_message="Error getting SQL database", return_format="json")
+        
+        return SQLDatabase.from_dict(item_dict, core_client=self)
+    
+    def list_sql_databases(self, workspace_id, with_properties = False):
+        """List SQL databases in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            with_properties (bool): Whether to get the item object with properties
+        Returns:
+            list: The list of SQL databases
+        """
+        return self.list_items(workspace_id = workspace_id, type = "SQLDatabases", with_properties = with_properties)
+    
+    def update_sql_database(self, workspace_id, sql_database_id, display_name = None, description = None, return_item=False):
+        """Update a SQL database in a workspace
+        Args:
+            workspace_id (str): The ID of the workspace
+            sql_database_id (str): The ID of the SQL database
+            display_name (str): The display name of the SQL database
+            description (str): The description of the SQL database
+        Returns:
+            dict: The updated SQL database
+        """
+        return self.update_item(workspace_id, sql_database_id, display_name = display_name, description = description,
+                                type="SQLDatabases", return_item=return_item)
+    
+
     # warehouses
 
     def create_warehouse(self, workspace_id, display_name, description = None):
@@ -2837,7 +4217,7 @@ class FabricClientCore(FabricClient):
         """
         return self.list_items(workspace_id = workspace_id, type = "warehouses", with_properties = with_properties)
 
-    def update_warehouse(self, workspace_id, warehouse_id, display_name = None, description = None, return_item="Default"):
+    def update_warehouse(self, workspace_id, warehouse_id, display_name = None, description = None, return_item=False):
         """Update a warehouse in a workspace
         Args:
             workspace_id (str): The ID of the workspace