databricks-sdk 0.65.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

databricks/sdk/service/dashboards.py

@@ -263,6 +263,9 @@ class GenieAttachment:
     query: Optional[GenieQueryAttachment] = None
     """Query Attachment if Genie responds with a SQL query"""
 
+    suggested_questions: Optional[GenieSuggestedQuestionsAttachment] = None
+    """Follow-up questions suggested by Genie"""
+
     text: Optional[TextAttachment] = None
     """Text Attachment if Genie responds with text"""
 
@@ -273,6 +276,8 @@ class GenieAttachment:
             body["attachment_id"] = self.attachment_id
         if self.query:
             body["query"] = self.query.as_dict()
+        if self.suggested_questions:
+            body["suggested_questions"] = self.suggested_questions.as_dict()
         if self.text:
             body["text"] = self.text.as_dict()
         return body
@@ -284,6 +289,8 @@ class GenieAttachment:
             body["attachment_id"] = self.attachment_id
         if self.query:
             body["query"] = self.query
+        if self.suggested_questions:
+            body["suggested_questions"] = self.suggested_questions
         if self.text:
             body["text"] = self.text
         return body
@@ -294,6 +301,7 @@ class GenieAttachment:
         return cls(
             attachment_id=d.get("attachment_id", None),
             query=_from_dict(d, "query", GenieQueryAttachment),
+            suggested_questions=_from_dict(d, "suggested_questions", GenieSuggestedQuestionsAttachment),
             text=_from_dict(d, "text", TextAttachment),
         )
 
@@ -413,6 +421,33 @@ class GenieConversationSummary:
         )
 
 
+@dataclass
+class GenieFeedback:
+    """Feedback containing rating and optional comment"""
+
+    rating: Optional[GenieFeedbackRating] = None
+    """The feedback rating"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieFeedback into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.rating is not None:
+            body["rating"] = self.rating.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenieFeedback into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.rating is not None:
+            body["rating"] = self.rating
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> GenieFeedback:
+        """Deserializes the GenieFeedback from a dictionary."""
+        return cls(rating=_enum(d, "rating", GenieFeedbackRating))
+
+
 class GenieFeedbackRating(Enum):
     """Feedback rating for Genie messages"""
 
@@ -572,6 +607,9 @@ class GenieMessage:
     error: Optional[MessageError] = None
     """Error message if Genie failed to respond to the message"""
 
+    feedback: Optional[GenieFeedback] = None
+    """User feedback for the message if provided"""
+
     last_updated_timestamp: Optional[int] = None
     """Timestamp when the message was last updated"""
 
@@ -597,6 +635,8 @@ class GenieMessage:
             body["created_timestamp"] = self.created_timestamp
         if self.error:
             body["error"] = self.error.as_dict()
+        if self.feedback:
+            body["feedback"] = self.feedback.as_dict()
         if self.id is not None:
             body["id"] = self.id
         if self.last_updated_timestamp is not None:
@@ -626,6 +666,8 @@ class GenieMessage:
             body["created_timestamp"] = self.created_timestamp
         if self.error:
             body["error"] = self.error
+        if self.feedback:
+            body["feedback"] = self.feedback
         if self.id is not None:
             body["id"] = self.id
         if self.last_updated_timestamp is not None:
@@ -651,6 +693,7 @@ class GenieMessage:
             conversation_id=d.get("conversation_id", None),
             created_timestamp=d.get("created_timestamp", None),
             error=_from_dict(d, "error", MessageError),
+            feedback=_from_dict(d, "feedback", GenieFeedback),
             id=d.get("id", None),
             last_updated_timestamp=d.get("last_updated_timestamp", None),
             message_id=d.get("message_id", None),
@@ -671,6 +714,8 @@ class GenieQueryAttachment:
     last_updated_timestamp: Optional[int] = None
     """Time when the user updated the query last"""
 
+    parameters: Optional[List[QueryAttachmentParameter]] = None
+
     query: Optional[str] = None
     """AI generated SQL query"""
 
@@ -693,6 +738,8 @@ class GenieQueryAttachment:
             body["id"] = self.id
         if self.last_updated_timestamp is not None:
             body["last_updated_timestamp"] = self.last_updated_timestamp
+        if self.parameters:
+            body["parameters"] = [v.as_dict() for v in self.parameters]
         if self.query is not None:
             body["query"] = self.query
         if self.query_result_metadata:
@@ -712,6 +759,8 @@ class GenieQueryAttachment:
             body["id"] = self.id
         if self.last_updated_timestamp is not None:
             body["last_updated_timestamp"] = self.last_updated_timestamp
+        if self.parameters:
+            body["parameters"] = self.parameters
         if self.query is not None:
             body["query"] = self.query
         if self.query_result_metadata:
@@ -729,6 +778,7 @@ class GenieQueryAttachment:
             description=d.get("description", None),
             id=d.get("id", None),
             last_updated_timestamp=d.get("last_updated_timestamp", None),
+            parameters=_repeated_dict(d, "parameters", QueryAttachmentParameter),
             query=d.get("query", None),
             query_result_metadata=_from_dict(d, "query_result_metadata", GenieResultMetadata),
             statement_id=d.get("statement_id", None),
@@ -779,6 +829,9 @@ class GenieSpace:
     description: Optional[str] = None
     """Description of the Genie Space"""
 
+    warehouse_id: Optional[str] = None
+    """Warehouse associated with the Genie Space"""
+
     def as_dict(self) -> dict:
         """Serializes the GenieSpace into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -788,6 +841,8 @@ class GenieSpace:
             body["space_id"] = self.space_id
         if self.title is not None:
             body["title"] = self.title
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -799,12 +854,19 @@ class GenieSpace:
             body["space_id"] = self.space_id
         if self.title is not None:
             body["title"] = self.title
+        if self.warehouse_id is not None:
+            body["warehouse_id"] = self.warehouse_id
         return body
 
     @classmethod
     def from_dict(cls, d: Dict[str, Any]) -> GenieSpace:
         """Deserializes the GenieSpace from a dictionary."""
-        return cls(description=d.get("description", None), space_id=d.get("space_id", None), title=d.get("title", None))
+        return cls(
+            description=d.get("description", None),
+            space_id=d.get("space_id", None),
+            title=d.get("title", None),
+            warehouse_id=d.get("warehouse_id", None),
+        )
 
 
 @dataclass
@@ -856,6 +918,33 @@ class GenieStartConversationResponse:
         )
 
 
+@dataclass
+class GenieSuggestedQuestionsAttachment:
+    """Follow-up questions suggested by Genie"""
+
+    questions: Optional[List[str]] = None
+    """The suggested follow-up questions"""
+
+    def as_dict(self) -> dict:
+        """Serializes the GenieSuggestedQuestionsAttachment into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.questions:
+            body["questions"] = [v for v in self.questions]
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the GenieSuggestedQuestionsAttachment into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.questions:
+            body["questions"] = self.questions
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> GenieSuggestedQuestionsAttachment:
+        """Deserializes the GenieSuggestedQuestionsAttachment from a dictionary."""
+        return cls(questions=d.get("questions", None))
+
+
 @dataclass
 class GetPublishedDashboardTokenInfoResponse:
     authorization_details: Optional[List[AuthorizationDetails]] = None
@@ -1053,6 +1142,7 @@ class MessageErrorType(Enum):
     DESCRIBE_QUERY_INVALID_SQL_ERROR = "DESCRIBE_QUERY_INVALID_SQL_ERROR"
     DESCRIBE_QUERY_TIMEOUT = "DESCRIBE_QUERY_TIMEOUT"
     DESCRIBE_QUERY_UNEXPECTED_FAILURE = "DESCRIBE_QUERY_UNEXPECTED_FAILURE"
+    EXCEEDED_MAX_TOKEN_LENGTH_EXCEPTION = "EXCEEDED_MAX_TOKEN_LENGTH_EXCEPTION"
     FUNCTIONS_NOT_AVAILABLE_EXCEPTION = "FUNCTIONS_NOT_AVAILABLE_EXCEPTION"
     FUNCTION_ARGUMENTS_INVALID_EXCEPTION = "FUNCTION_ARGUMENTS_INVALID_EXCEPTION"
     FUNCTION_ARGUMENTS_INVALID_JSON_EXCEPTION = "FUNCTION_ARGUMENTS_INVALID_JSON_EXCEPTION"
@@ -1063,6 +1153,8 @@ class MessageErrorType(Enum):
     GENERIC_CHAT_COMPLETION_SERVICE_EXCEPTION = "GENERIC_CHAT_COMPLETION_SERVICE_EXCEPTION"
     GENERIC_SQL_EXEC_API_CALL_EXCEPTION = "GENERIC_SQL_EXEC_API_CALL_EXCEPTION"
     ILLEGAL_PARAMETER_DEFINITION_EXCEPTION = "ILLEGAL_PARAMETER_DEFINITION_EXCEPTION"
+    INTERNAL_CATALOG_MISSING_UC_PATH_EXCEPTION = "INTERNAL_CATALOG_MISSING_UC_PATH_EXCEPTION"
+    INTERNAL_CATALOG_PATH_OVERLAP_EXCEPTION = "INTERNAL_CATALOG_PATH_OVERLAP_EXCEPTION"
     INVALID_CERTIFIED_ANSWER_FUNCTION_EXCEPTION = "INVALID_CERTIFIED_ANSWER_FUNCTION_EXCEPTION"
     INVALID_CERTIFIED_ANSWER_IDENTIFIER_EXCEPTION = "INVALID_CERTIFIED_ANSWER_IDENTIFIER_EXCEPTION"
     INVALID_CHAT_COMPLETION_ARGUMENTS_JSON_EXCEPTION = "INVALID_CHAT_COMPLETION_ARGUMENTS_JSON_EXCEPTION"
@@ -1176,6 +1268,42 @@ class PublishedDashboard:
         )
 
 
+@dataclass
+class QueryAttachmentParameter:
+    keyword: Optional[str] = None
+
+    sql_type: Optional[str] = None
+
+    value: Optional[str] = None
+
+    def as_dict(self) -> dict:
+        """Serializes the QueryAttachmentParameter into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.keyword is not None:
+            body["keyword"] = self.keyword
+        if self.sql_type is not None:
+            body["sql_type"] = self.sql_type
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the QueryAttachmentParameter into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.keyword is not None:
+            body["keyword"] = self.keyword
+        if self.sql_type is not None:
+            body["sql_type"] = self.sql_type
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> QueryAttachmentParameter:
+        """Deserializes the QueryAttachmentParameter from a dictionary."""
+        return cls(keyword=d.get("keyword", None), sql_type=d.get("sql_type", None), value=d.get("value", None))
+
+
 @dataclass
 class Result:
     is_truncated: Optional[bool] = None
@@ -1921,8 +2049,8 @@ class GenieAPI:
         :param space_id: str
           The ID of the Genie space to retrieve conversations from.
         :param include_all: bool (optional)
-          Include all conversations in the space across all users. Requires "Can Manage" permission on the
-          space.
+          Include all conversations in the space across all users. Requires at least CAN MANAGE permission on
+          the space.
         :param page_size: int (optional)
           Maximum number of conversations to return per page
         :param page_token: str (optional)
@@ -1970,15 +2098,7 @@ class GenieAPI:
         res = self._api.do("GET", "/api/2.0/genie/spaces", query=query, headers=headers)
         return GenieListSpacesResponse.from_dict(res)
 
-    def send_message_feedback(
-        self,
-        space_id: str,
-        conversation_id: str,
-        message_id: str,
-        rating: GenieFeedbackRating,
-        *,
-        comment: Optional[str] = None,
-    ):
+    def send_message_feedback(self, space_id: str, conversation_id: str, message_id: str, rating: GenieFeedbackRating):
         """Send feedback for a message.
 
         :param space_id: str
@@ -1989,14 +2109,10 @@ class GenieAPI:
           The ID associated with the message to provide feedback for.
         :param rating: :class:`GenieFeedbackRating`
           The rating (POSITIVE, NEGATIVE, or NONE).
-        :param comment: str (optional)
-          Optional text feedback that will be stored as a comment.
 
 
         """
         body = {}
-        if comment is not None:
-            body["comment"] = comment
         if rating is not None:
             body["rating"] = rating.value
         headers = {

databricks/sdk/service/database.py

@@ -18,6 +18,38 @@ _LOG = logging.getLogger("databricks.sdk")
 # all definitions in this file are in alphabetical order
 
 
+@dataclass
+class CustomTag:
+    key: Optional[str] = None
+    """The key of the custom tag."""
+
+    value: Optional[str] = None
+    """The value of the custom tag."""
+
+    def as_dict(self) -> dict:
+        """Serializes the CustomTag into a dictionary suitable for use as a JSON request body."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    def as_shallow_dict(self) -> dict:
+        """Serializes the CustomTag into a shallow dictionary of its immediate attributes."""
+        body = {}
+        if self.key is not None:
+            body["key"] = self.key
+        if self.value is not None:
+            body["value"] = self.value
+        return body
+
+    @classmethod
+    def from_dict(cls, d: Dict[str, Any]) -> CustomTag:
+        """Deserializes the CustomTag from a dictionary."""
+        return cls(key=d.get("key", None), value=d.get("value", None))
+
+
 @dataclass
 class DatabaseCatalog:
     name: str
@@ -125,48 +157,46 @@ class DatabaseInstance:
     creator: Optional[str] = None
     """The email of the creator of the instance."""
 
+    custom_tags: Optional[List[CustomTag]] = None
+    """Custom tags associated with the instance. This field is only included on create and update
+    responses."""
+
+    effective_capacity: Optional[str] = None
+    """Deprecated. The sku of the instance; this field will always match the value of capacity."""
+
+    effective_custom_tags: Optional[List[CustomTag]] = None
+    """The recorded custom tags associated with the instance."""
+
     effective_enable_pg_native_login: Optional[bool] = None
-    """xref AIP-129. `enable_pg_native_login` is owned by the client, while
-    `effective_enable_pg_native_login` is owned by the server. `enable_pg_native_login` will only be
-    set in Create/Update response messages if and only if the user provides the field via the
-    request. `effective_enable_pg_native_login` on the other hand will always bet set in all
-    response messages (Create/Update/Get/List)."""
+    """Whether the instance has PG native password login enabled."""
 
     effective_enable_readable_secondaries: Optional[bool] = None
-    """xref AIP-129. `enable_readable_secondaries` is owned by the client, while
-    `effective_enable_readable_secondaries` is owned by the server. `enable_readable_secondaries`
-    will only be set in Create/Update response messages if and only if the user provides the field
-    via the request. `effective_enable_readable_secondaries` on the other hand will always bet set
-    in all response messages (Create/Update/Get/List)."""
+    """Whether secondaries serving read-only traffic are enabled. Defaults to false."""
 
     effective_node_count: Optional[int] = None
-    """xref AIP-129. `node_count` is owned by the client, while `effective_node_count` is owned by the
-    server. `node_count` will only be set in Create/Update response messages if and only if the user
-    provides the field via the request. `effective_node_count` on the other hand will always bet set
-    in all response messages (Create/Update/Get/List)."""
+    """The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults
+    to 1 primary and 0 secondaries."""
 
     effective_retention_window_in_days: Optional[int] = None
-    """xref AIP-129. `retention_window_in_days` is owned by the client, while
-    `effective_retention_window_in_days` is owned by the server. `retention_window_in_days` will
-    only be set in Create/Update response messages if and only if the user provides the field via
-    the request. `effective_retention_window_in_days` on the other hand will always bet set in all
-    response messages (Create/Update/Get/List)."""
+    """The retention window for the instance. This is the time window in days for which the historical
+    data is retained."""
 
     effective_stopped: Optional[bool] = None
-    """xref AIP-129. `stopped` is owned by the client, while `effective_stopped` is owned by the
-    server. `stopped` will only be set in Create/Update response messages if and only if the user
-    provides the field via the request. `effective_stopped` on the other hand will always bet set in
-    all response messages (Create/Update/Get/List)."""
+    """Whether the instance is stopped."""
+
+    effective_usage_policy_id: Optional[str] = None
+    """The policy that is applied to the instance."""
 
     enable_pg_native_login: Optional[bool] = None
-    """Whether the instance has PG native password login enabled. Defaults to true."""
+    """Whether to enable PG native password login on the instance. Defaults to false."""
 
     enable_readable_secondaries: Optional[bool] = None
     """Whether to enable secondaries to serve read-only traffic. Defaults to false."""
 
     node_count: Optional[int] = None
     """The number of nodes in the instance, composed of 1 primary and 0 or more secondaries. Defaults
-    to 1 primary and 0 secondaries."""
+    to 1 primary and 0 secondaries. This field is input only, see effective_node_count for the
+    output."""
 
     parent_instance_ref: Optional[DatabaseInstanceRef] = None
     """The ref of the parent instance. This is only available if the instance is child instance. Input:
@@ -191,11 +221,14 @@ class DatabaseInstance:
     """The current state of the instance."""
 
     stopped: Optional[bool] = None
-    """Whether the instance is stopped."""
+    """Whether to stop the instance. An input only param, see effective_stopped for the output."""
 
     uid: Optional[str] = None
     """An immutable UUID identifier for the instance."""
 
+    usage_policy_id: Optional[str] = None
+    """The desired usage policy to associate with the instance."""
+
     def as_dict(self) -> dict:
         """Serializes the DatabaseInstance into a dictionary suitable for use as a JSON request body."""
         body = {}
@@ -207,6 +240,12 @@ class DatabaseInstance:
             body["creation_time"] = self.creation_time
         if self.creator is not None:
             body["creator"] = self.creator
+        if self.custom_tags:
+            body["custom_tags"] = [v.as_dict() for v in self.custom_tags]
+        if self.effective_capacity is not None:
+            body["effective_capacity"] = self.effective_capacity
+        if self.effective_custom_tags:
+            body["effective_custom_tags"] = [v.as_dict() for v in self.effective_custom_tags]
         if self.effective_enable_pg_native_login is not None:
             body["effective_enable_pg_native_login"] = self.effective_enable_pg_native_login
         if self.effective_enable_readable_secondaries is not None:
@@ -217,6 +256,8 @@ class DatabaseInstance:
             body["effective_retention_window_in_days"] = self.effective_retention_window_in_days
         if self.effective_stopped is not None:
             body["effective_stopped"] = self.effective_stopped
+        if self.effective_usage_policy_id is not None:
+            body["effective_usage_policy_id"] = self.effective_usage_policy_id
         if self.enable_pg_native_login is not None:
             body["enable_pg_native_login"] = self.enable_pg_native_login
         if self.enable_readable_secondaries is not None:
@@ -241,6 +282,8 @@ class DatabaseInstance:
             body["stopped"] = self.stopped
         if self.uid is not None:
             body["uid"] = self.uid
+        if self.usage_policy_id is not None:
+            body["usage_policy_id"] = self.usage_policy_id
         return body
 
     def as_shallow_dict(self) -> dict:
@@ -254,6 +297,12 @@ class DatabaseInstance:
             body["creation_time"] = self.creation_time
         if self.creator is not None:
             body["creator"] = self.creator
+        if self.custom_tags:
+            body["custom_tags"] = self.custom_tags
+        if self.effective_capacity is not None:
+            body["effective_capacity"] = self.effective_capacity
+        if self.effective_custom_tags:
+            body["effective_custom_tags"] = self.effective_custom_tags
         if self.effective_enable_pg_native_login is not None:
             body["effective_enable_pg_native_login"] = self.effective_enable_pg_native_login
         if self.effective_enable_readable_secondaries is not None:
@@ -264,6 +313,8 @@ class DatabaseInstance:
             body["effective_retention_window_in_days"] = self.effective_retention_window_in_days
         if self.effective_stopped is not None:
             body["effective_stopped"] = self.effective_stopped
+        if self.effective_usage_policy_id is not None:
+            body["effective_usage_policy_id"] = self.effective_usage_policy_id
         if self.enable_pg_native_login is not None:
             body["enable_pg_native_login"] = self.enable_pg_native_login
         if self.enable_readable_secondaries is not None:
@@ -288,6 +339,8 @@ class DatabaseInstance:
             body["stopped"] = self.stopped
         if self.uid is not None:
             body["uid"] = self.uid
+        if self.usage_policy_id is not None:
+            body["usage_policy_id"] = self.usage_policy_id
         return body
 
     @classmethod
@@ -298,11 +351,15 @@ class DatabaseInstance:
             child_instance_refs=_repeated_dict(d, "child_instance_refs", DatabaseInstanceRef),
             creation_time=d.get("creation_time", None),
             creator=d.get("creator", None),
+            custom_tags=_repeated_dict(d, "custom_tags", CustomTag),
+            effective_capacity=d.get("effective_capacity", None),
+            effective_custom_tags=_repeated_dict(d, "effective_custom_tags", CustomTag),
             effective_enable_pg_native_login=d.get("effective_enable_pg_native_login", None),
             effective_enable_readable_secondaries=d.get("effective_enable_readable_secondaries", None),
             effective_node_count=d.get("effective_node_count", None),
             effective_retention_window_in_days=d.get("effective_retention_window_in_days", None),
             effective_stopped=d.get("effective_stopped", None),
+            effective_usage_policy_id=d.get("effective_usage_policy_id", None),
             enable_pg_native_login=d.get("enable_pg_native_login", None),
             enable_readable_secondaries=d.get("enable_readable_secondaries", None),
             name=d.get("name", None),
@@ -315,6 +372,7 @@ class DatabaseInstance:
             state=_enum(d, "state", DatabaseInstanceState),
             stopped=d.get("stopped", None),
             uid=d.get("uid", None),
+            usage_policy_id=d.get("usage_policy_id", None),
         )
 
 
@@ -335,12 +393,9 @@ class DatabaseInstanceRef:
     provided as input to create a child instance."""
 
     effective_lsn: Optional[str] = None
-    """xref AIP-129. `lsn` is owned by the client, while `effective_lsn` is owned by the server. `lsn`
-    will only be set in Create/Update response messages if and only if the user provides the field
-    via the request. `effective_lsn` on the other hand will always bet set in all response messages
-    (Create/Update/Get/List). For a parent ref instance, this is the LSN on the parent instance from
-    which the instance was created. For a child ref instance, this is the LSN on the instance from
-    which the child instance was created."""
+    """For a parent ref instance, this is the LSN on the parent instance from which the instance was
+    created. For a child ref instance, this is the LSN on the instance from which the child instance
+    was created."""
 
     lsn: Optional[str] = None
     """User-specified WAL LSN of the ref database instance.
@@ -400,25 +455,34 @@ class DatabaseInstanceRef:
 class DatabaseInstanceRole:
     """A DatabaseInstanceRole represents a Postgres role in a database instance."""
 
+    name: str
+    """The name of the role. This is the unique identifier for the role in an instance."""
+
     attributes: Optional[DatabaseInstanceRoleAttributes] = None
-    """API-exposed Postgres role attributes"""
+    """The desired API-exposed Postgres role attribute to associate with the role. Optional."""
+
+    effective_attributes: Optional[DatabaseInstanceRoleAttributes] = None
+    """The attributes that are applied to the role."""
 
     identity_type: Optional[DatabaseInstanceRoleIdentityType] = None
     """The type of the role."""
 
+    instance_name: Optional[str] = None
+
     membership_role: Optional[DatabaseInstanceRoleMembershipRole] = None
     """An enum value for a standard role that this role is a member of."""
 
-    name: Optional[str] = None
-    """The name of the role. This is the unique identifier for the role in an instance."""
-
     def as_dict(self) -> dict:
         """Serializes the DatabaseInstanceRole into a dictionary suitable for use as a JSON request body."""
         body = {}
         if self.attributes:
             body["attributes"] = self.attributes.as_dict()
+        if self.effective_attributes:
+            body["effective_attributes"] = self.effective_attributes.as_dict()
         if self.identity_type is not None:
             body["identity_type"] = self.identity_type.value
+        if self.instance_name is not None:
+            body["instance_name"] = self.instance_name
         if self.membership_role is not None:
             body["membership_role"] = self.membership_role.value
         if self.name is not None:
@@ -430,8 +494,12 @@ class DatabaseInstanceRole:
         body = {}
         if self.attributes:
             body["attributes"] = self.attributes
+        if self.effective_attributes:
+            body["effective_attributes"] = self.effective_attributes
         if self.identity_type is not None:
             body["identity_type"] = self.identity_type
+        if self.instance_name is not None:
+            body["instance_name"] = self.instance_name
         if self.membership_role is not None:
             body["membership_role"] = self.membership_role
         if self.name is not None:
@@ -443,7 +511,9 @@ class DatabaseInstanceRole:
         """Deserializes the DatabaseInstanceRole from a dictionary."""
         return cls(
             attributes=_from_dict(d, "attributes", DatabaseInstanceRoleAttributes),
+            effective_attributes=_from_dict(d, "effective_attributes", DatabaseInstanceRoleAttributes),
             identity_type=_enum(d, "identity_type", DatabaseInstanceRoleIdentityType),
+            instance_name=d.get("instance_name", None),
             membership_role=_enum(d, "membership_role", DatabaseInstanceRoleMembershipRole),
             name=d.get("name", None),
         )
@@ -1537,22 +1607,32 @@ class DatabaseAPI:
         return self.create_database_instance(database_instance=database_instance).result(timeout=timeout)
 
     def create_database_instance_role(
-        self, instance_name: str, database_instance_role: DatabaseInstanceRole
+        self,
+        instance_name: str,
+        database_instance_role: DatabaseInstanceRole,
+        *,
+        database_instance_name: Optional[str] = None,
     ) -> DatabaseInstanceRole:
         """Create a role for a Database Instance.
 
         :param instance_name: str
         :param database_instance_role: :class:`DatabaseInstanceRole`
+        :param database_instance_name: str (optional)
 
         :returns: :class:`DatabaseInstanceRole`
         """
         body = database_instance_role.as_dict()
+        query = {}
+        if database_instance_name is not None:
+            query["database_instance_name"] = database_instance_name
         headers = {
             "Accept": "application/json",
             "Content-Type": "application/json",
         }
 
-        res = self._api.do("POST", f"/api/2.0/database/instances/{instance_name}/roles", body=body, headers=headers)
+        res = self._api.do(
+            "POST", f"/api/2.0/database/instances/{instance_name}/roles", query=query, body=body, headers=headers
+        )
         return DatabaseInstanceRole.from_dict(res)
 
     def create_database_table(self, table: DatabaseTable) -> DatabaseTable:
@@ -1611,12 +1691,8 @@ class DatabaseAPI:
           By default, a instance cannot be deleted if it has descendant instances created via PITR. If this
           flag is specified as true, all descendent instances will be deleted as well.
         :param purge: bool (optional)
-          Note purge=false is in development. If false, the database instance is soft deleted (implementation
-          pending). Soft deleted instances behave as if they are deleted, and cannot be used for CRUD
-          operations nor connected to. However they can be undeleted by calling the undelete API for a limited
-          time (implementation pending). If true, the database instance is hard deleted and cannot be
-          undeleted. For the time being, setting this value to true is required to delete an instance (soft
-          delete is not yet supported).
+          Deprecated. Omitting the field or setting it to true will result in the field being hard deleted.
+          Setting a value of false will throw a bad request.
 
 
         """