regenerate from cloud 186c87db6f

.generated

@@ -33,6 +33,7 @@ pkg/hanzoai/cloud/api/dataroom_api.py
 pkg/hanzoai/cloud/api/dataset_api.py
 pkg/hanzoai/cloud/api/deploy_api.py
 pkg/hanzoai/cloud/api/destination_api.py
+pkg/hanzoai/cloud/api/dns_api.py
 pkg/hanzoai/cloud/api/domain_api.py
 pkg/hanzoai/cloud/api/engine_api.py
 pkg/hanzoai/cloud/api/entitlement_api.py
@@ -2124,6 +2125,7 @@ pkg/hanzoai/cloud/models/rollback_req.py
 pkg/hanzoai/cloud/models/rollup.py
 pkg/hanzoai/cloud/models/rollup_allotment.py
 pkg/hanzoai/cloud/models/rollup_balance.py
+pkg/hanzoai/cloud/models/room_work.py
 pkg/hanzoai/cloud/models/root.py
 pkg/hanzoai/cloud/models/round_input.py
 pkg/hanzoai/cloud/models/round_out.py
@@ -2324,6 +2326,9 @@ pkg/hanzoai/cloud/models/tariff_in.py
 pkg/hanzoai/cloud/models/taxon.py
 pkg/hanzoai/cloud/models/taxon_in.py
 pkg/hanzoai/cloud/models/taxonomy.py
+pkg/hanzoai/cloud/models/team_room.py
+pkg/hanzoai/cloud/models/team_room_bind.py
+pkg/hanzoai/cloud/models/team_rooms.py
 pkg/hanzoai/cloud/models/template_catalog.py
 pkg/hanzoai/cloud/models/template_override.py
 pkg/hanzoai/cloud/models/template_reply.py

.spec-lock

@@ -1,4 +1,4 @@
-ref=939b09d4ad32c9be3c018abae25dda0569a3bb85
-sha256=087024f65af714e61e7c2327fda49b3e8494972c40d2babd3b14ff6dcdd2712a
+ref=186c87db6fec3c6e47b62e9a76d932e0c8646651
+sha256=bcc530927aec91f8546694728139841fa7e2cedb9458ecaace5b05efd639f73a
 repo=hanzo-inc/cloud
 path=openapi.yaml

pkg/hanzoai/cloud/__init__.py

@@ -51,6 +51,7 @@ __all__ = [
     "DatasetApi",
     "DeployApi",
     "DestinationApi",
+    "DnsApi",
     "DomainApi",
     "EngineApi",
     "EntitlementApi",
@@ -2146,6 +2147,7 @@ __all__ = [
     "Rollup",
     "RollupAllotment",
     "RollupBalance",
+    "RoomWork",
     "Root",
     "RoundInput",
     "RoundOut",
@@ -2347,6 +2349,9 @@ __all__ = [
     "Taxon",
     "TaxonIn",
     "Taxonomy",
+    "TeamRoom",
+    "TeamRoomBind",
+    "TeamRooms",
     "TemplateCatalog",
     "TemplateOverride",
     "TemplateReply",
@@ -2505,6 +2510,7 @@ from hanzoai.cloud.api.dataroom_api import DataroomApi as DataroomApi
 from hanzoai.cloud.api.dataset_api import DatasetApi as DatasetApi
 from hanzoai.cloud.api.deploy_api import DeployApi as DeployApi
 from hanzoai.cloud.api.destination_api import DestinationApi as DestinationApi
+from hanzoai.cloud.api.dns_api import DnsApi as DnsApi
 from hanzoai.cloud.api.domain_api import DomainApi as DomainApi
 from hanzoai.cloud.api.engine_api import EngineApi as EngineApi
 from hanzoai.cloud.api.entitlement_api import EntitlementApi as EntitlementApi
@@ -4604,6 +4610,7 @@ from hanzoai.cloud.models.rollback_req import RollbackReq as RollbackReq
 from hanzoai.cloud.models.rollup import Rollup as Rollup
 from hanzoai.cloud.models.rollup_allotment import RollupAllotment as RollupAllotment
 from hanzoai.cloud.models.rollup_balance import RollupBalance as RollupBalance
+from hanzoai.cloud.models.room_work import RoomWork as RoomWork
 from hanzoai.cloud.models.root import Root as Root
 from hanzoai.cloud.models.round_input import RoundInput as RoundInput
 from hanzoai.cloud.models.round_out import RoundOut as RoundOut
@@ -4805,6 +4812,9 @@ from hanzoai.cloud.models.tariff_in import TariffIn as TariffIn
 from hanzoai.cloud.models.taxon import Taxon as Taxon
 from hanzoai.cloud.models.taxon_in import TaxonIn as TaxonIn
 from hanzoai.cloud.models.taxonomy import Taxonomy as Taxonomy
+from hanzoai.cloud.models.team_room import TeamRoom as TeamRoom
+from hanzoai.cloud.models.team_room_bind import TeamRoomBind as TeamRoomBind
+from hanzoai.cloud.models.team_rooms import TeamRooms as TeamRooms
 from hanzoai.cloud.models.template_catalog import TemplateCatalog as TemplateCatalog
 from hanzoai.cloud.models.template_override import TemplateOverride as TemplateOverride
 from hanzoai.cloud.models.template_reply import TemplateReply as TemplateReply

pkg/hanzoai/cloud/api/__init__.py

@@ -34,6 +34,7 @@ from hanzoai.cloud.api.dataroom_api import DataroomApi
 from hanzoai.cloud.api.dataset_api import DatasetApi
 from hanzoai.cloud.api.deploy_api import DeployApi
 from hanzoai.cloud.api.destination_api import DestinationApi
+from hanzoai.cloud.api.dns_api import DnsApi
 from hanzoai.cloud.api.domain_api import DomainApi
 from hanzoai.cloud.api.engine_api import EngineApi
 from hanzoai.cloud.api.entitlement_api import EntitlementApi

pkg/hanzoai/cloud/api/account_api.py

@@ -853,9 +853,9 @@ class AccountApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> CsrfResp:
-        """IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs).
+        """IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for.
 
-        IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs). The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a write as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a write.
+        IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for. The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a change as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a change.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -916,9 +916,9 @@ class AccountApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> ApiResponse[CsrfResp]:
-        """IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs).
+        """IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for.
 
-        IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs). The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a write as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a write.
+        IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for. The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a change as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a change.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request
@@ -979,9 +979,9 @@ class AccountApi:
         _headers: Optional[Dict[StrictStr, Any]] = None,
         _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
     ) -> RESTResponseType:
-        """IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs).
+        """IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for.
 
-        IssueCSRFToken mints the anti-CSRF token a browser echoes as X-CSRF-Token on every money write (mint/revoke a key, top up, onboard, and the billing/commerce write verbs). The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a write as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a write.
+        IssueCSRFToken mints the anti-forgery token a browser echoes as X-CSRF-Token on every change it asks for. The token is bound to the caller's validated identity and expires, so one minted for one identity cannot authorize a change as another.  It is answered no-store, so it is never cached by a shared proxy. This is the same-origin endpoint the embedded console reads — the Same-Origin Policy is what stops a cross-site page from reading the response and forging a change.
 
         :param _request_timeout: timeout setting for this request. If one
                                  number provided, it will be total request

pkg/hanzoai/cloud/api/agents_api.py

@@ -3428,6 +3428,7 @@ class AgentsApi:
         parent: Annotated[Optional[StrictStr], Field(description="Parent scopes the page to the direct children of one session. Ignored when root is set; with neither, only ROOT sessions come back.")] = None,
         status: Annotated[Optional[StrictStr], Field(description="Status filters to running, paused, done or error.")] = None,
         project: Annotated[Optional[StrictStr], Field(description="Project filters to the sessions tagged with one product slug.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the page. Absent, zero or over 500 reads as 100.")] = None,
         _request_timeout: Union[
             None,
@@ -3454,6 +3455,8 @@ class AgentsApi:
         :type status: str
         :param project: Project filters to the sessions tagged with one product slug.
         :type project: str
+        :param room: Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.
+        :type room: str
         :param limit: Limit caps the page. Absent, zero or over 500 reads as 100.
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -3483,6 +3486,7 @@ class AgentsApi:
             parent=parent,
             status=status,
             project=project,
+            room=room,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3511,6 +3515,7 @@ class AgentsApi:
         parent: Annotated[Optional[StrictStr], Field(description="Parent scopes the page to the direct children of one session. Ignored when root is set; with neither, only ROOT sessions come back.")] = None,
         status: Annotated[Optional[StrictStr], Field(description="Status filters to running, paused, done or error.")] = None,
         project: Annotated[Optional[StrictStr], Field(description="Project filters to the sessions tagged with one product slug.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the page. Absent, zero or over 500 reads as 100.")] = None,
         _request_timeout: Union[
             None,
@@ -3537,6 +3542,8 @@ class AgentsApi:
         :type status: str
         :param project: Project filters to the sessions tagged with one product slug.
         :type project: str
+        :param room: Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.
+        :type room: str
         :param limit: Limit caps the page. Absent, zero or over 500 reads as 100.
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -3566,6 +3573,7 @@ class AgentsApi:
             parent=parent,
             status=status,
             project=project,
+            room=room,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3594,6 +3602,7 @@ class AgentsApi:
         parent: Annotated[Optional[StrictStr], Field(description="Parent scopes the page to the direct children of one session. Ignored when root is set; with neither, only ROOT sessions come back.")] = None,
         status: Annotated[Optional[StrictStr], Field(description="Status filters to running, paused, done or error.")] = None,
         project: Annotated[Optional[StrictStr], Field(description="Project filters to the sessions tagged with one product slug.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the page. Absent, zero or over 500 reads as 100.")] = None,
         _request_timeout: Union[
             None,
@@ -3620,6 +3629,8 @@ class AgentsApi:
         :type status: str
         :param project: Project filters to the sessions tagged with one product slug.
         :type project: str
+        :param room: Room filters to the sessions started in one collaborative room — the query a workspace view runs to show what has been run in it.
+        :type room: str
         :param limit: Limit caps the page. Absent, zero or over 500 reads as 100.
         :type limit: int
         :param _request_timeout: timeout setting for this request. If one
@@ -3649,6 +3660,7 @@ class AgentsApi:
             parent=parent,
             status=status,
             project=project,
+            room=room,
             limit=limit,
             _request_auth=_request_auth,
             _content_type=_content_type,
@@ -3672,6 +3684,7 @@ class AgentsApi:
         parent,
         status,
         project,
+        room,
         limit,
         _request_auth,
         _content_type,
@@ -3711,6 +3724,10 @@ class AgentsApi:
             
             _query_params.append(('project', project))
             
+        if room is not None:
+            
+            _query_params.append(('room', room))
+            
         if limit is not None:
             
             _query_params.append(('limit', limit))

pkg/hanzoai/cloud/api/meet_api.py

@@ -18,6 +18,7 @@ from typing_extensions import Annotated
 
 from pydantic import Field, StrictStr
 from typing_extensions import Annotated
+from hanzoai.cloud.models.call import Call
 from hanzoai.cloud.models.meet_health import MeetHealth
 from hanzoai.cloud.models.record_in import RecordIn
 from hanzoai.cloud.models.recording import Recording
@@ -525,6 +526,286 @@ class MeetApi:
 
 
 
+    @validate_call
+    def meet_call(
+        self,
+        workspace: Annotated[StrictStr, Field(description="Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against.")],
+        room: Annotated[StrictStr, Field(description="Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> Call:
+        """Where a room's call happens
+
+        Answers where a room's call happens, for a caller who may join it.  It is the \"resolved at render\" half of HIP-0523 §12: a surface showing a channel asks for the room's call at the moment it draws one, rather than reading a media room name someone stored on the room. Nothing here is persisted and nothing is created — a media room begins existing when the first participant connects and stops when the last leaves, so there is no call to create and none to clean up.  AUTHORIZATION IS THE JOIN DECISION, unchanged and shared. It delegates to state.admits, the same function POST /v1/meet/getToken and all three recording operations admit on, so a caller who is told where a call is, is a caller who could have joined it. Answering the address to someone who cannot join would make this a workspace-membership oracle for anyone who can guess a room id.  It deliberately does NOT report whether a call is in progress. That is a fact the media server holds and this binary would have to ask for it over the network, which is a different decision with a different failure mode — and reporting \"nobody is in this call\" when the question could not be asked would be exactly the unknown-rendered-as-zero this surface refuses elsewhere.
+
+        :param workspace: Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against. (required)
+        :type workspace: str
+        :param room: Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._meet_call_serialize(
+            workspace=workspace,
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Call",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def meet_call_with_http_info(
+        self,
+        workspace: Annotated[StrictStr, Field(description="Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against.")],
+        room: Annotated[StrictStr, Field(description="Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[Call]:
+        """Where a room's call happens
+
+        Answers where a room's call happens, for a caller who may join it.  It is the \"resolved at render\" half of HIP-0523 §12: a surface showing a channel asks for the room's call at the moment it draws one, rather than reading a media room name someone stored on the room. Nothing here is persisted and nothing is created — a media room begins existing when the first participant connects and stops when the last leaves, so there is no call to create and none to clean up.  AUTHORIZATION IS THE JOIN DECISION, unchanged and shared. It delegates to state.admits, the same function POST /v1/meet/getToken and all three recording operations admit on, so a caller who is told where a call is, is a caller who could have joined it. Answering the address to someone who cannot join would make this a workspace-membership oracle for anyone who can guess a room id.  It deliberately does NOT report whether a call is in progress. That is a fact the media server holds and this binary would have to ask for it over the network, which is a different decision with a different failure mode — and reporting \"nobody is in this call\" when the question could not be asked would be exactly the unknown-rendered-as-zero this surface refuses elsewhere.
+
+        :param workspace: Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against. (required)
+        :type workspace: str
+        :param room: Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._meet_call_serialize(
+            workspace=workspace,
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Call",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def meet_call_without_preload_content(
+        self,
+        workspace: Annotated[StrictStr, Field(description="Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against.")],
+        room: Annotated[StrictStr, Field(description="Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Where a room's call happens
+
+        Answers where a room's call happens, for a caller who may join it.  It is the \"resolved at render\" half of HIP-0523 §12: a surface showing a channel asks for the room's call at the moment it draws one, rather than reading a media room name someone stored on the room. Nothing here is persisted and nothing is created — a media room begins existing when the first participant connects and stops when the last leaves, so there is no call to create and none to clean up.  AUTHORIZATION IS THE JOIN DECISION, unchanged and shared. It delegates to state.admits, the same function POST /v1/meet/getToken and all three recording operations admit on, so a caller who is told where a call is, is a caller who could have joined it. Answering the address to someone who cannot join would make this a workspace-membership oracle for anyone who can guess a room id.  It deliberately does NOT report whether a call is in progress. That is a fact the media server holds and this binary would have to ask for it over the network, which is a different decision with a different failure mode — and reporting \"nobody is in this call\" when the question could not be asked would be exactly the unknown-rendered-as-zero this surface refuses elsewhere.
+
+        :param workspace: Workspace is the workspace uuid holding the room, as GET /v1/team/rooms reports it. It is the segment the caller's membership is checked against. (required)
+        :type workspace: str
+        :param room: Room is the room's own id within that workspace, as GET /v1/team/rooms reports it. It is opaque here: meet keeps no rooms and cannot say whether one exists, only whether this caller may be seated in the workspace holding it. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._meet_call_serialize(
+            workspace=workspace,
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "Call",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _meet_call_serialize(
+        self,
+        workspace,
+        room,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        if workspace is not None:
+            
+            _query_params.append(('workspace', workspace))
+            
+        if room is not None:
+            
+            _query_params.append(('room', room))
+            
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/meet/call',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def meet_record_read(
         self,

pkg/hanzoai/cloud/api/team_api.py

@@ -27,6 +27,9 @@ from hanzoai.cloud.models.cookie_ack import CookieAck
 from hanzoai.cloud.models.plan_info import PlanInfo
 from hanzoai.cloud.models.provider_info import ProviderInfo
 from hanzoai.cloud.models.stats_out import StatsOut
+from hanzoai.cloud.models.team_room import TeamRoom
+from hanzoai.cloud.models.team_room_bind import TeamRoomBind
+from hanzoai.cloud.models.team_rooms import TeamRooms
 
 from hanzoai.cloud.api_client import ApiClient, RequestSerialized
 from hanzoai.cloud.api_response import ApiResponse
@@ -2576,6 +2579,252 @@ class TeamApi:
 
 
 
+    @validate_call
+    def get_team_rooms(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> TeamRooms:
+        """Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.
+
+        Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.  It reads the SAME Chunter documents the transactor serves, so a room opened in the Team client appears here with no sync, and a facet written here is read by anything holding the document. Direct messages are included: a room between two people is a room with no name, not a different kind of thing.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_team_rooms_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRooms",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_team_rooms_with_http_info(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[TeamRooms]:
+        """Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.
+
+        Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.  It reads the SAME Chunter documents the transactor serves, so a room opened in the Team client appears here with no sync, and a facet written here is read by anything holding the document. Direct messages are included: a room between two people is a room with no name, not a different kind of thing.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_team_rooms_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRooms",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_team_rooms_without_preload_content(
+        self,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.
+
+        Returns every room of the caller's org, across the workspaces it owns, with the work facet each carries.  It reads the SAME Chunter documents the transactor serves, so a room opened in the Team client appears here with no sync, and a facet written here is read by anything holding the document. Direct messages are included: a room between two people is a room with no name, not a different kind of thing.
+
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_team_rooms_serialize(
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRooms",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_team_rooms_serialize(
+        self,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/team/rooms',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def get_team_transactor_api_v1_statistics(
         self,
@@ -4665,3 +4914,292 @@ class TeamApi:
         )
 
 
+
+
+    @validate_call
+    def put_team_rooms_by_id(
+        self,
+        id: Annotated[StrictStr, Field(description="ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.")],
+        team_room_bind: TeamRoomBind,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> TeamRoom:
+        """States what a room is for: its lifecycle intent, and what it is about.
+
+        States what a room is for: its lifecycle intent, and what it is about. It answers the room as it now stands.  The write is a platform MIXIN on the room document, applied through the SAME applyTx path the Team client's own writes take and broadcast to every connected client — so a room bound here updates live in an open workspace rather than on the next reload.
+
+        :param id: ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write. (required)
+        :type id: str
+        :param team_room_bind: (required)
+        :type team_room_bind: TeamRoomBind
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._put_team_rooms_by_id_serialize(
+            id=id,
+            team_room_bind=team_room_bind,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRoom",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def put_team_rooms_by_id_with_http_info(
+        self,
+        id: Annotated[StrictStr, Field(description="ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.")],
+        team_room_bind: TeamRoomBind,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[TeamRoom]:
+        """States what a room is for: its lifecycle intent, and what it is about.
+
+        States what a room is for: its lifecycle intent, and what it is about. It answers the room as it now stands.  The write is a platform MIXIN on the room document, applied through the SAME applyTx path the Team client's own writes take and broadcast to every connected client — so a room bound here updates live in an open workspace rather than on the next reload.
+
+        :param id: ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write. (required)
+        :type id: str
+        :param team_room_bind: (required)
+        :type team_room_bind: TeamRoomBind
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._put_team_rooms_by_id_serialize(
+            id=id,
+            team_room_bind=team_room_bind,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRoom",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def put_team_rooms_by_id_without_preload_content(
+        self,
+        id: Annotated[StrictStr, Field(description="ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.")],
+        team_room_bind: TeamRoomBind,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """States what a room is for: its lifecycle intent, and what it is about.
+
+        States what a room is for: its lifecycle intent, and what it is about. It answers the room as it now stands.  The write is a platform MIXIN on the room document, applied through the SAME applyTx path the Team client's own writes take and broadcast to every connected client — so a room bound here updates live in an open workspace rather than on the next reload.
+
+        :param id: ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write. (required)
+        :type id: str
+        :param team_room_bind: (required)
+        :type team_room_bind: TeamRoomBind
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._put_team_rooms_by_id_serialize(
+            id=id,
+            team_room_bind=team_room_bind,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "TeamRoom",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _put_team_rooms_by_id_serialize(
+        self,
+        id,
+        team_room_bind,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if id is not None:
+            _path_params['id'] = id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+        if team_room_bind is not None:
+            _body_params = team_room_bind
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+        # set the HTTP header `Content-Type`
+        if _content_type:
+            _header_params['Content-Type'] = _content_type
+        else:
+            _default_content_type = (
+                self.api_client.select_header_content_type(
+                    [
+                        'application/json'
+                    ]
+                )
+            )
+            if _default_content_type is not None:
+                _header_params['Content-Type'] = _default_content_type
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='PUT',
+            resource_path='/v1/team/rooms/{id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

pkg/hanzoai/cloud/api/todo_api.py

@@ -24,6 +24,7 @@ from hanzoai.cloud.models.issue_hit import IssueHit
 from hanzoai.cloud.models.issue_hits import IssueHits
 from hanzoai.cloud.models.issue_view import IssueView
 from hanzoai.cloud.models.new_issue import NewIssue
+from hanzoai.cloud.models.room_work import RoomWork
 from hanzoai.cloud.models.todo_project import TodoProject
 
 from hanzoai.cloud.api_client import ApiClient, RequestSerialized
@@ -668,6 +669,7 @@ class TodoApi:
         status: Annotated[Optional[StrictStr], Field(description="Status keeps one board column: backlog, todo, in_progress, done, canceled.")] = None,
         kind: Annotated[Optional[StrictStr], Field(description="Kind keeps one shape: issue, pr, epic.")] = None,
         repo: Annotated[Optional[StrictStr], Field(description="Repo keeps issues bound to one git repository.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.")] = None,
         source: Annotated[Optional[StrictStr], Field(description="Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.")] = None,
         assignee: Annotated[Optional[StrictStr], Field(description="Assignee keeps issues held by one person. Pass \"me\" for yourself.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the answer; 0 means the default, and anything above the ceiling is clamped rather than refused — a search that errors on being too broad teaches people to guess.")] = None,
@@ -698,6 +700,8 @@ class TodoApi:
         :type kind: str
         :param repo: Repo keeps issues bound to one git repository.
         :type repo: str
+        :param room: Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.
+        :type room: str
         :param source: Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.
         :type source: str
         :param assignee: Assignee keeps issues held by one person. Pass \"me\" for yourself.
@@ -732,6 +736,7 @@ class TodoApi:
             status=status,
             kind=kind,
             repo=repo,
+            room=room,
             source=source,
             assignee=assignee,
             limit=limit,
@@ -763,6 +768,7 @@ class TodoApi:
         status: Annotated[Optional[StrictStr], Field(description="Status keeps one board column: backlog, todo, in_progress, done, canceled.")] = None,
         kind: Annotated[Optional[StrictStr], Field(description="Kind keeps one shape: issue, pr, epic.")] = None,
         repo: Annotated[Optional[StrictStr], Field(description="Repo keeps issues bound to one git repository.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.")] = None,
         source: Annotated[Optional[StrictStr], Field(description="Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.")] = None,
         assignee: Annotated[Optional[StrictStr], Field(description="Assignee keeps issues held by one person. Pass \"me\" for yourself.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the answer; 0 means the default, and anything above the ceiling is clamped rather than refused — a search that errors on being too broad teaches people to guess.")] = None,
@@ -793,6 +799,8 @@ class TodoApi:
         :type kind: str
         :param repo: Repo keeps issues bound to one git repository.
         :type repo: str
+        :param room: Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.
+        :type room: str
         :param source: Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.
         :type source: str
         :param assignee: Assignee keeps issues held by one person. Pass \"me\" for yourself.
@@ -827,6 +835,7 @@ class TodoApi:
             status=status,
             kind=kind,
             repo=repo,
+            room=room,
             source=source,
             assignee=assignee,
             limit=limit,
@@ -858,6 +867,7 @@ class TodoApi:
         status: Annotated[Optional[StrictStr], Field(description="Status keeps one board column: backlog, todo, in_progress, done, canceled.")] = None,
         kind: Annotated[Optional[StrictStr], Field(description="Kind keeps one shape: issue, pr, epic.")] = None,
         repo: Annotated[Optional[StrictStr], Field(description="Repo keeps issues bound to one git repository.")] = None,
+        room: Annotated[Optional[StrictStr], Field(description="Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.")] = None,
         source: Annotated[Optional[StrictStr], Field(description="Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.")] = None,
         assignee: Annotated[Optional[StrictStr], Field(description="Assignee keeps issues held by one person. Pass \"me\" for yourself.")] = None,
         limit: Annotated[Optional[StrictInt], Field(description="Limit caps the answer; 0 means the default, and anything above the ceiling is clamped rather than refused — a search that errors on being too broad teaches people to guess.")] = None,
@@ -888,6 +898,8 @@ class TodoApi:
         :type kind: str
         :param repo: Repo keeps issues bound to one git repository.
         :type repo: str
+        :param room: Room keeps issues bound to one collaboration room, spelled \"<workspace>_<room>\" — the exact value GET /v1/meet/call answers with, so a channel's call and its todo list name the room the same way. This is the read a channel view runs to draw its own list; it spans every board of the org, because the work a channel is about is not confined to one board.
+        :type room: str
         :param source: Source keeps one origin: team, git, crm, helpdesk, cms, agent. \"git\" is how you ask for the mirrored GitHub issues specifically.
         :type source: str
         :param assignee: Assignee keeps issues held by one person. Pass \"me\" for yourself.
@@ -922,6 +934,7 @@ class TodoApi:
             status=status,
             kind=kind,
             repo=repo,
+            room=room,
             source=source,
             assignee=assignee,
             limit=limit,
@@ -948,6 +961,7 @@ class TodoApi:
         status,
         kind,
         repo,
+        room,
         source,
         assignee,
         limit,
@@ -993,6 +1007,10 @@ class TodoApi:
             
             _query_params.append(('repo', repo))
             
+        if room is not None:
+            
+            _query_params.append(('room', room))
+            
         if source is not None:
             
             _query_params.append(('source', source))
@@ -2188,6 +2206,267 @@ class TodoApi:
 
 
 
+    @validate_call
+    def get_todo_rooms_by_room(
+        self,
+        room: Annotated[StrictStr, Field(description="Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RoomWork:
+        """Summarises one room's work.
+
+        Summarises one room's work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal's org and nothing else, so a caller cannot read another tenant's channel by naming its room.
+
+        :param room: Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_todo_rooms_by_room_serialize(
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RoomWork",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def get_todo_rooms_by_room_with_http_info(
+        self,
+        room: Annotated[StrictStr, Field(description="Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[RoomWork]:
+        """Summarises one room's work.
+
+        Summarises one room's work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal's org and nothing else, so a caller cannot read another tenant's channel by naming its room.
+
+        :param room: Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_todo_rooms_by_room_serialize(
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RoomWork",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def get_todo_rooms_by_room_without_preload_content(
+        self,
+        room: Annotated[StrictStr, Field(description="Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path.")],
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Summarises one room's work.
+
+        Summarises one room's work.  The room is opaque here and is deliberately not resolved: this package cannot say whether a room exists — apps/team owns that document — so an unknown room answers an EMPTY board rather than a 404. That is the honest answer and the useful one: a channel that has never had an item filed in it and a channel id that was mistyped both have no work, and inventing a distinction would require this surface to hold a second copy of the room list (HIP-0523 §2 forbids it, and it would drift the first time a room was renamed).  Tenancy is the validated principal's org and nothing else, so a caller cannot read another tenant's channel by naming its room.
+
+        :param room: Room is the room, spelled \"<workspace>_<room>\" — the same value GET /v1/meet/call answers with, so a channel's call and its work name the room identically. From the path. (required)
+        :type room: str
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._get_todo_rooms_by_room_serialize(
+            room=room,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "RoomWork",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _get_todo_rooms_by_room_serialize(
+        self,
+        room,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if room is not None:
+            _path_params['room'] = room
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'bearer'
+        ]
+
+        return self.api_client.param_serialize(
+            method='GET',
+            resource_path='/v1/todo/rooms/{room}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
     @validate_call
     def patch_todo_projects_by_key(
         self,

pkg/hanzoai/cloud/models/__init__.py

@@ -2016,6 +2016,7 @@ from hanzoai.cloud.models.rollback_req import RollbackReq
 from hanzoai.cloud.models.rollup import Rollup
 from hanzoai.cloud.models.rollup_allotment import RollupAllotment
 from hanzoai.cloud.models.rollup_balance import RollupBalance
+from hanzoai.cloud.models.room_work import RoomWork
 from hanzoai.cloud.models.root import Root
 from hanzoai.cloud.models.round_input import RoundInput
 from hanzoai.cloud.models.round_out import RoundOut
@@ -2217,6 +2218,9 @@ from hanzoai.cloud.models.tariff_in import TariffIn
 from hanzoai.cloud.models.taxon import Taxon
 from hanzoai.cloud.models.taxon_in import TaxonIn
 from hanzoai.cloud.models.taxonomy import Taxonomy
+from hanzoai.cloud.models.team_room import TeamRoom
+from hanzoai.cloud.models.team_room_bind import TeamRoomBind
+from hanzoai.cloud.models.team_rooms import TeamRooms
 from hanzoai.cloud.models.template_catalog import TemplateCatalog
 from hanzoai.cloud.models.template_override import TemplateOverride
 from hanzoai.cloud.models.template_reply import TemplateReply

pkg/hanzoai/cloud/models/allowance.py

@@ -28,10 +28,11 @@ class Allowance(BaseModel):
     """ # noqa: E501
     limit: Optional[StrictInt] = Field(default=None, description="calls the plan allows per period; 0 = unbounded")
     plan: Optional[StrictStr] = Field(default=None, description="the tier the limit came from")
-    resets: Optional[StrictInt] = Field(default=None, description="unix seconds; when the count starts again")
+    resets: Optional[StrictInt] = Field(default=None, description="unix seconds; when THAT window starts again")
     spent: Optional[StrictBool] = Field(default=None, description="the subject is at the limit")
     used: Optional[StrictInt] = Field(default=None, description="Used is how many zero-priced calls this subject has been SERVED in the period ending at Resets — the UTC calendar day. Only a served call counts, so an admission check, a refusal, or a vendor that never answered leaves it where it stood. It stops AT Limit rather than climbing past it, so Limit-Used is what remains and never goes negative.")
-    __properties: ClassVar[List[str]] = ["limit", "plan", "resets", "spent", "used"]
+    window: Optional[StrictStr] = Field(default=None, description="Window is which ceiling these numbers describe — \"hour\" or \"day\" — because a caller is held to both and only one of them is the answer. It is the window that REFUSED where one did, and otherwise the one with least left, so Limit-Used is always the number that will actually stop them next. Empty where no window bounds the subject at all.")
+    __properties: ClassVar[List[str]] = ["limit", "plan", "resets", "spent", "used", "window"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -88,7 +89,8 @@ class Allowance(BaseModel):
             "plan": obj.get("plan"),
             "resets": obj.get("resets"),
             "spent": obj.get("spent"),
-            "used": obj.get("used")
+            "used": obj.get("used"),
+            "window": obj.get("window")
         })
         return _obj
 

pkg/hanzoai/cloud/models/call.py

@@ -17,7 +17,7 @@ import pprint
 import re  # noqa: F401
 import json
 
-from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
 from typing import Any, ClassVar, Dict, List, Optional
 from typing import Optional, Set
 from typing_extensions import Self
@@ -26,13 +26,10 @@ class Call(BaseModel):
     """
     Call
     """ # noqa: E501
-    agent: Optional[StrictStr] = Field(default=None, description="Agent names the Hanzo assistant handling the call. Set means the call was answered by that assistant rather than connected to a person.")
-    var_from: Optional[StrictStr] = Field(default=None, description="From is the calling number in E.164. It must be one this org holds: a carrier refuses an origination from a number nobody proved they own.", alias="from")
-    id: Optional[StrictStr] = Field(default=None, description="ID is the carrier's handle for the call — what a hangup or a lookup names.")
-    org: Optional[StrictStr] = Field(default=None, description="Org is the tenant the call was placed for or received by.")
-    status: Optional[StrictStr] = Field(default=None, description="Status is where the call is: \"queued\", \"ringing\", \"answered\", \"completed\" or \"failed\". Only the last two are terminal.")
-    to: Optional[StrictStr] = Field(default=None, description="To is the called number in E.164.")
-    __properties: ClassVar[List[str]] = ["agent", "from", "id", "org", "status", "to"]
+    name: Optional[StrictStr] = Field(default=None, description="Name is the media room to join: the value POST /v1/meet/getToken takes as roomName, and the value the media server keys participants on.")
+    ready: Optional[StrictBool] = Field(default=None, description="Ready reports that this deployment can mint a join token for this room. It is false on a deployment holding no media-server key, where Name is still correct — the name is a property of the room and the key is a property of the deployment, so a caller learns the room's identity either way and learns not to offer a join button.")
+    ws: Optional[StrictStr] = Field(default=None, description="WS is where the media plane is — the address a client opens its own browser-to-server connection to. Empty when this deployment has not been told where its media server lives, which is reported rather than refused: a surface can say a call is unavailable without a second request.")
+    __properties: ClassVar[List[str]] = ["name", "ready", "ws"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -85,12 +82,9 @@ class Call(BaseModel):
             return cls.model_validate(obj)
 
         _obj = cls.model_validate({
-            "agent": obj.get("agent"),
-            "from": obj.get("from"),
-            "id": obj.get("id"),
-            "org": obj.get("org"),
-            "status": obj.get("status"),
-            "to": obj.get("to")
+            "name": obj.get("name"),
+            "ready": obj.get("ready"),
+            "ws": obj.get("ws")
         })
         return _obj
 

pkg/hanzoai/cloud/models/captable_class_holding.py

@@ -30,7 +30,7 @@ class CaptableClassHolding(BaseModel):
     class_type: Optional[StrictStr] = Field(default=None, description="ClassType is COMMON or PREFERRED.", alias="classType")
     issued: Optional[StrictInt] = Field(default=None, description="Issued is how many shares of the class have been issued.")
     name: Optional[StrictStr] = Field(default=None, description="Name is the class name.")
-    share_class_id: Optional[StrictStr] = Field(default=None, description="ShareClassID is the share class.", alias="shareClassId")
+    share_class_id: Optional[StrictStr] = Field(default=None, description="ShareClassID addresses the class this position is for.", alias="shareClassId")
     __properties: ClassVar[List[str]] = ["authorized", "classType", "issued", "name", "shareClassId"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/captable_holding.py

@@ -31,7 +31,7 @@ class CaptableHolding(BaseModel):
     options: Optional[StrictInt] = Field(default=None, description="Options is the shares under this stakeholder's non-terminal option grants.")
     ownership_pct: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, description="OwnershipPct is fullyDiluted as a percentage of the company's fullyDilutedShares, rounded to two decimals; 0 when nothing is issued.", alias="ownershipPct")
     shares: Optional[StrictInt] = Field(default=None, description="Shares is the shares this stakeholder holds by certificate.")
-    stakeholder_id: Optional[StrictStr] = Field(default=None, description="StakeholderID is the stakeholder.", alias="stakeholderId")
+    stakeholder_id: Optional[StrictStr] = Field(default=None, description="StakeholderID addresses the stakeholder these totals are for.", alias="stakeholderId")
     __properties: ClassVar[List[str]] = ["fullyDiluted", "name", "options", "ownershipPct", "shares", "stakeholderId"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/captable_round_detail.py

@@ -29,7 +29,7 @@ class CaptableRoundDetail(BaseModel):
     CaptableRoundDetail
     """ # noqa: E501
     investments: Optional[List[CaptableRoundInvestment]] = Field(default=None, description="Investments is every investment into this round, oldest first.")
-    round: Optional[CaptableRound] = Field(default=None, description="Round is the round itself.")
+    round: Optional[CaptableRound] = Field(default=None, description="Round is the round's own terms — name, type, valuation, target and status — as against the investments beside it.")
     __properties: ClassVar[List[str]] = ["investments", "round"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/csrf_resp.py

@@ -26,8 +26,8 @@ class CsrfResp(BaseModel):
     """
     CsrfResp
     """ # noqa: E501
-    csrf_token: Optional[StrictStr] = Field(default=None, description="Token is the value to send back in the X-CSRF-Token header. It is bound to the caller's identity, so it authorizes writes as them and as nobody else.", alias="csrfToken")
-    expires_in: Optional[StrictInt] = Field(default=None, description="ExpiresIn is the token's lifetime in seconds. Fetch a new one when it lapses; a write with an expired token is refused.", alias="expiresIn")
+    csrf_token: Optional[StrictStr] = Field(default=None, description="Token is the value to send back in the X-CSRF-Token header. It is bound to the caller's identity, so it authorizes changes as them and as nobody else.", alias="csrfToken")
+    expires_in: Optional[StrictInt] = Field(default=None, description="ExpiresIn is the token's lifetime in seconds. Fetch a new one when it lapses; a change with an expired token is refused.", alias="expiresIn")
     __properties: ClassVar[List[str]] = ["csrfToken", "expiresIn"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/dataroom_document_one.py

@@ -27,7 +27,7 @@ class DataroomDocumentOne(BaseModel):
     """
     DataroomDocumentOne
     """ # noqa: E501
-    document: Optional[DataroomDocument] = Field(default=None, description="Document is the document itself.")
+    document: Optional[DataroomDocument] = Field(default=None, description="Document is the requested document's METADATA. Its bytes are a separate read, GET /v1/dataroom/documents/{id}/file.")
     __properties: ClassVar[List[str]] = ["document"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/esign_pdf.py

@@ -27,7 +27,7 @@ class EsignPDF(BaseModel):
     EsignPDF
     """ # noqa: E501
     filename: Optional[StrictStr] = Field(default=None, description="Filename is the name to save it under, built from the title and marked _signed once it is sealed.")
-    id: Optional[StrictStr] = Field(default=None, description="ID is the document.")
+    id: Optional[StrictStr] = Field(default=None, description="ID is the document this PDF was rendered from.")
     pdf_base64: Optional[StrictStr] = Field(default=None, description="PdfBase64 is the PDF itself, base64-encoded. There is one field either way, so Sealed is what tells you which artifact you are holding.", alias="pdfBase64")
     sealed: Optional[StrictBool] = Field(default=None, description="Sealed is whether this is the SEALED artifact — the field values rendered onto the page and a real x509 PKCS#7 signature applied — rather than the original upload.")
     status: Optional[StrictStr] = Field(default=None, description="Status is the document's state at the moment it was read.")

pkg/hanzoai/cloud/models/framework_row.py

@@ -32,7 +32,7 @@ class FrameworkRow(BaseModel):
     publisher: Optional[StrictStr] = Field(default=None, description="Publisher is who publishes it.")
     total: Optional[StrictInt] = Field(default=None, description="Total is how many clauses the standard publishes.")
     unit: Optional[StrictStr] = Field(default=None, description="Unit is what one clause is; Units is its plural.")
-    units: Optional[StrictStr] = Field(default=None, description="Units is the plural of Unit.")
+    units: Optional[StrictStr] = Field(default=None, description="Units is Unit's plural, carried so a caller renders \"12 controls\" without having to pluralise a word it does not know.")
     __properties: ClassVar[List[str]] = ["edition", "framework", "name", "publisher", "total", "unit", "units"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/issue_hit.py

@@ -32,11 +32,12 @@ class IssueHit(BaseModel):
     priority: Optional[StrictStr] = Field(default=None, description="Priority is urgent, high, medium, low or none. Never empty — an unset priority is the value \"none\".")
     project: Optional[StrictStr] = Field(default=None, description="Project is the board key the issue is on. It and Number are the issue's address in every other route on this surface, which is why a hit carries it.")
     repo: Optional[StrictStr] = Field(default=None, description="Repo is the git repository the issue is bound to, empty when it is not repo-bound.")
+    room: Optional[StrictStr] = Field(default=None, description="Room is the collaboration room the issue belongs to, spelled \"<workspace>_<room>\" — empty when it is not room-bound, which is most of them. It is here so an org-wide search says which channel each item came from without a second read.")
     source: Optional[StrictStr] = Field(default=None, description="Source is which surface opened it: team, git, crm, helpdesk, cms or agent. \"git\" is how the mirrored forge and GitHub rows are spelled.")
     status: Optional[StrictStr] = Field(default=None, description="Status is the board column: backlog, todo, in_progress, done or canceled. Claiming moves backlog and todo to in_progress and leaves the other three where they are.")
     title: Optional[StrictStr] = Field(default=None, description="Title is the issue's one-line summary — what the q filter matched, along with the description.")
     url: Optional[StrictStr] = Field(default=None, description="URL is the row's external anchor — its extRef — which is a link only when the feeder sent one. A mirrored GitHub issue carries \"github:owner/repo#123\" and an agent's PR row carries the pushed branch. Empty for a row opened here.")
-    __properties: ClassVar[List[str]] = ["assignee", "kind", "number", "priority", "project", "repo", "source", "status", "title", "url"]
+    __properties: ClassVar[List[str]] = ["assignee", "kind", "number", "priority", "project", "repo", "room", "source", "status", "title", "url"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -95,6 +96,7 @@ class IssueHit(BaseModel):
             "priority": obj.get("priority"),
             "project": obj.get("project"),
             "repo": obj.get("repo"),
+            "room": obj.get("room"),
             "source": obj.get("source"),
             "status": obj.get("status"),
             "title": obj.get("title"),

pkg/hanzoai/cloud/models/new_issue.py

@@ -30,7 +30,7 @@ class NewIssue(BaseModel):
     key: Optional[StrictStr] = Field(default=None, description="Key is the board — the repository name, from the path.")
     priority: Optional[StrictStr] = Field(default=None, description="Priority is one of none, urgent, high, medium or low.")
     status: Optional[StrictStr] = Field(default=None, description="Status is the board column to open into: backlog, todo, in_progress, done or canceled. Empty opens into backlog.")
-    title: Optional[StrictStr] = Field(default=None, description="Title is required.")
+    title: Optional[StrictStr] = Field(default=None, description="Title is the one line the card is read by on the board. Blank or whitespace is refused — an untitled card cannot be told apart from any other.")
     __properties: ClassVar[List[str]] = ["description", "key", "priority", "status", "title"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/policy_list.py

@@ -26,7 +26,7 @@ class PolicyList(BaseModel):
     """
     PolicyList
     """ # noqa: E501
-    policies: Optional[List[Any]] = Field(default=None, description="Policies is the list.")
+    policies: Optional[List[Any]] = Field(default=None, description="Policies is the organization's published policy documents, each as the centre holds it.")
     __properties: ClassVar[List[str]] = ["policies"]
 
     model_config = ConfigDict(

pkg/hanzoai/cloud/models/reference_version.py

@@ -28,7 +28,7 @@ class ReferenceVersion(BaseModel):
     """ # noqa: E501
     as_of: Optional[StrictStr] = Field(default=None, description="AsOf is when the oldest of them was current, RFC 3339.", alias="asOf")
     refusal: Optional[StrictStr] = Field(default=None, description="Refusal is why it could not be consulted, when it could not.")
-    set: Optional[StrictStr] = Field(default=None, description="Set is the set.")
+    set: Optional[StrictStr] = Field(default=None, description="Set is the name the consulted set is addressed by.")
     stale: Optional[StrictBool] = Field(default=None, description="Stale is whether it is past its freshness bound.")
     version: Optional[StrictStr] = Field(default=None, description="Version is every contributing publisher and its content digest.")
     __properties: ClassVar[List[str]] = ["asOf", "refusal", "set", "stale", "version"]

pkg/hanzoai/cloud/models/register_req.py

@@ -36,13 +36,14 @@ class RegisterReq(BaseModel):
     provider: Optional[StrictStr] = Field(default=None, description="Account tag — the linked AI account this session ran under (login manager).")
     published: Optional[StrictBool] = Field(default=None, description="Published opens this session's story to the public build route. It is refused without a Project, because that route is keyed on (org, project) — a build with no product is not a story anyone can open. False keeps it org-only.")
     repo: Optional[StrictStr] = Field(default=None, description="Repo is the code being worked on, up to 512 characters. A label the surface states; nothing resolves it against the forge.")
+    room: Optional[StrictStr] = Field(default=None, description="Room is the collaborative room this run was started in (HIP-0523), so a workspace view can list the sessions of one room. It is PROVENANCE and is set only here: there is deliberately no way to move a session to another room, so it is absent from the patch input and from UpdateSession's SET list.")
     status: Optional[StrictStr] = Field(default=None, description="Status opens the session in one of running, paused, done or error. Empty means running. A TERMINAL status here (done, error) records a session that has already finished — its end time is stamped now — and nothing can move it afterwards.")
     target: Optional[StrictStr] = Field(default=None, description="Target names a run-target the org has registered. Unlike Host and Repo it IS resolved: a target that does not exist in this org is a 400, so a session can never claim to run on another tenant's machine. Empty names no machine.")
     task_run_id: Optional[StrictStr] = Field(default=None, description="TaskRunID is that workflow's particular run, same bound. Recorded, not resolved: this surface does not check the workflow exists.", alias="taskRunId")
     task_workflow_id: Optional[StrictStr] = Field(default=None, description="TaskWorkflowID links this session to the hanzoai/tasks workflow that executes it, up to 256 characters. Set it and control commands are forwarded to that engine; leave it and the running surface polls for them instead.", alias="taskWorkflowId")
     terminal: Optional[StrictStr] = Field(default=None, description="Terminal is the URL this session's live terminal is published at, so the console can watch it. Optional — a session that publishes nothing is still a session.")
     title: Optional[StrictStr] = Field(default=None, description="Title is the human line a card shows, up to 512 characters. Optional, and changeable later.")
-    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "cwd", "host", "parentSessionId", "project", "provider", "published", "repo", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title"]
+    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "cwd", "host", "parentSessionId", "project", "provider", "published", "repo", "room", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -105,6 +106,7 @@ class RegisterReq(BaseModel):
             "provider": obj.get("provider"),
             "published": obj.get("published"),
             "repo": obj.get("repo"),
+            "room": obj.get("room"),
             "status": obj.get("status"),
             "target": obj.get("target"),
             "taskRunId": obj.get("taskRunId"),

pkg/hanzoai/cloud/models/room_work.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Hanzo Cloud API
+
+    The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictInt, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class RoomWork(BaseModel):
+    """
+    RoomWork
+    """ # noqa: E501
+    open: Optional[StrictInt] = Field(default=None, description="Open is how many items are still work: everything whose status does not end it. It is the number a channel header shows.")
+    room: Optional[StrictStr] = Field(default=None, description="Room is the room these counts are for, echoed back as it was resolved.")
+    status: Optional[Dict[str, StrictInt]] = Field(default=None, description="Status is the count per board column, carrying EVERY column this surface knows — an empty column reads 0 rather than being absent, so a caller can render the board without inventing the vocabulary. The keys are the same closed set every other operation here validates against.")
+    total: Optional[StrictInt] = Field(default=None, description="Total is every item bound to this room, settled ones included, so Total minus Open is what the room has finished.")
+    updated: Optional[StrictInt] = Field(default=None, description="Updated is when anything in this room's work last moved, in unix seconds. ABSENT when the room has no work at all: zero would read as the epoch, and a room nobody has filed anything in has no last activity rather than an infinitely old one. Total is 0 in exactly that case.")
+    __properties: ClassVar[List[str]] = ["open", "room", "status", "total", "updated"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of RoomWork from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of RoomWork from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "open": obj.get("open"),
+            "room": obj.get("room"),
+            "status": obj.get("status"),
+            "total": obj.get("total"),
+            "updated": obj.get("updated")
+        })
+        return _obj
+
+

pkg/hanzoai/cloud/models/session_detail.py

@@ -48,6 +48,7 @@ class SessionDetail(BaseModel):
     published: Optional[StrictBool] = None
     recent_events: Optional[List[EventView]] = Field(default=None, description="RecentEvents is the 50 most recent turns, OLDEST of those first — a transcript to read down, not a feed. The promoted `events` integer says how many the log holds in total; page the rest from a seq.", alias="recentEvents")
     repo: Optional[StrictStr] = None
+    room: Optional[StrictStr] = None
     root_session_id: Optional[StrictStr] = Field(default=None, alias="rootSessionId")
     started_at: Optional[StrictStr] = Field(default=None, alias="startedAt")
     status: Optional[StrictStr] = None
@@ -57,7 +58,7 @@ class SessionDetail(BaseModel):
     terminal: Optional[StrictStr] = None
     title: Optional[StrictStr] = None
     updated_at: Optional[StrictStr] = Field(default=None, alias="updatedAt")
-    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "childSessions", "children", "createdAt", "cwd", "endedAt", "events", "host", "id", "lastEvent", "org", "parentSessionId", "project", "provider", "published", "recentEvents", "repo", "rootSessionId", "startedAt", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title", "updatedAt"]
+    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "childSessions", "children", "createdAt", "cwd", "endedAt", "events", "host", "id", "lastEvent", "org", "parentSessionId", "project", "provider", "published", "recentEvents", "repo", "room", "rootSessionId", "startedAt", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title", "updatedAt"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -146,6 +147,7 @@ class SessionDetail(BaseModel):
             "published": obj.get("published"),
             "recentEvents": [EventView.from_dict(_item) for _item in obj["recentEvents"]] if obj.get("recentEvents") is not None else None,
             "repo": obj.get("repo"),
+            "room": obj.get("room"),
             "rootSessionId": obj.get("rootSessionId"),
             "startedAt": obj.get("startedAt"),
             "status": obj.get("status"),

pkg/hanzoai/cloud/models/session_view.py

@@ -44,6 +44,7 @@ class SessionView(BaseModel):
     provider: Optional[StrictStr] = Field(default=None, description="Provider is the linked AI account's provider (claude | codex | hanzo | …) that served this run. Empty when the surface did not say.")
     published: Optional[StrictBool] = Field(default=None, description="Published is the author's decision to let anyone read this session's story at the public build route. It only ever widens READ access to a session that already exists and grants nothing else; false, an unpublished session is invisible there no matter who asks. It cannot be true without a Project, because that route is keyed on (org, project).")
     repo: Optional[StrictStr] = Field(default=None, description="Repo is the code the session is working on, as the surface reported it. It is truth the SURFACE states, so it is a label rather than something resolved here.")
+    room: Optional[StrictStr] = Field(default=None, description="Room is the collaborative room this run was started in (HIP-0523), empty when it came from anywhere else — a CLI, a schedule, an API call. It is what lets a workspace view show the runs of one room beside its messages.")
     root_session_id: Optional[StrictStr] = Field(default=None, description="RootSessionID is the top of this session's tree, inherited from the parent and shared by every node in one flow. A root session's own id, when it has no parent. It is the key one indexed read pulls a whole flow by, and what ?root= narrows a list or a stream to.", alias="rootSessionId")
     started_at: Optional[StrictStr] = Field(default=None, description="StartedAt is when the session opened, RFC 3339 in UTC to the second.", alias="startedAt")
     status: Optional[StrictStr] = Field(default=None, description="Status is one of exactly four: running, paused, done, error. running and paused are LIVE; done and error are TERMINAL and monotonic — once a session reaches one it can never go back, because reopening a finished run would fabricate liveness. A control command never moves it: the surface running the agent reports the new status, and until it does the command is only recorded.")
@@ -53,7 +54,7 @@ class SessionView(BaseModel):
     terminal: Optional[StrictStr] = Field(default=None, description="Terminal is where this session can be WATCHED — the URL the machine published for its live terminal. Omitted when it publishes none.")
     title: Optional[StrictStr] = Field(default=None, description="Title is the human line a card shows (\"ship the landing page\"), up to 512 characters. Free text, and the one field a surface may rewrite as the work turns out to be something else.")
     updated_at: Optional[StrictStr] = Field(default=None, description="UpdatedAt is the session's last-activity clock, same format. It moves on a write to the row — a status, a title, a re-dispatch — AND on every appended turn, because the append bumps it in the same transaction. The list is ordered on CreatedAt, so this is the field that says whether a session is still saying anything.", alias="updatedAt")
-    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "children", "createdAt", "cwd", "endedAt", "events", "host", "id", "lastEvent", "org", "parentSessionId", "project", "provider", "published", "repo", "rootSessionId", "startedAt", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title", "updatedAt"]
+    __properties: ClassVar[List[str]] = ["account", "actor", "agent", "children", "createdAt", "cwd", "endedAt", "events", "host", "id", "lastEvent", "org", "parentSessionId", "project", "provider", "published", "repo", "room", "rootSessionId", "startedAt", "status", "target", "taskRunId", "taskWorkflowId", "terminal", "title", "updatedAt"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -126,6 +127,7 @@ class SessionView(BaseModel):
             "provider": obj.get("provider"),
             "published": obj.get("published"),
             "repo": obj.get("repo"),
+            "room": obj.get("room"),
             "rootSessionId": obj.get("rootSessionId"),
             "startedAt": obj.get("startedAt"),
             "status": obj.get("status"),

pkg/hanzoai/cloud/models/team_room.py

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+"""
+    Hanzo Cloud API
+
+    The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictBool, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TeamRoom(BaseModel):
+    """
+    TeamRoom
+    """ # noqa: E501
+    archived: Optional[StrictBool] = Field(default=None, description="Archived reports that the room has been closed. It is the platform's own Space attribute — the same one the Team client writes — and NOT a field of the work facet, so there is exactly one answer to \"is this room open\".")
+    bindings: Optional[List[StrictStr]] = Field(default=None, description="Bindings are what this room is ABOUT, each a \"<kind>:<ref>\" string — \"project:acme/web\", \"repo:hanzoai/cloud\", \"issue:1010\". One list rather than one field per kind, because the next thing a room can be about should not be a schema change; and a bound value is opaque here on purpose, since the app that owns a project is the app that can resolve one. HIP-0523 §2: a binding is a REFERENCE, never a copy — a room holding an issue's title or status would be the parallel work-item store HIP-1160 §1 forbids.")
+    direct: Optional[StrictBool] = Field(default=None, description="Direct reports that this is a room between people rather than a named room. It is derived from the document's class, so it cannot disagree with what the client will render.")
+    id: Optional[StrictStr] = Field(default=None, description="ID is the room document's own id, and the value the bind op addresses. It is unique within a workspace, not across the org.")
+    life: Optional[StrictStr] = Field(default=None, description="Life is the room's lifecycle INTENT — \"standing\" or \"bound\" (HIP-0523 §2). Absent on the document it reads \"standing\": a room nobody classified is one that persists.")
+    members: Optional[List[StrictStr]] = Field(default=None, description="Members are the account uuids in the room, agents included: an agent projects as a workspace member under a uuid derived from its id, so a caller comparing this against GET /v1/team/bots learns which rooms an agent is in.")
+    name: Optional[StrictStr] = Field(default=None, description="Name is what a person sees in a sidebar. A direct message carries none, so this is empty for one — the members are its name.")
+    private: Optional[StrictBool] = Field(default=None, description="Private reports that the room is restricted to its members.")
+    topic: Optional[StrictStr] = Field(default=None, description="Topic is the room's own one-line subject, as the Team client sets it.")
+    workspace: Optional[StrictStr] = Field(default=None, description="Workspace is the workspace uuid holding this room. It is part of the room's address: two workspaces of one org may each hold a room with the same name, and only the pair identifies one.")
+    __properties: ClassVar[List[str]] = ["archived", "bindings", "direct", "id", "life", "members", "name", "private", "topic", "workspace"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TeamRoom from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TeamRoom from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "archived": obj.get("archived"),
+            "bindings": obj.get("bindings"),
+            "direct": obj.get("direct"),
+            "id": obj.get("id"),
+            "life": obj.get("life"),
+            "members": obj.get("members"),
+            "name": obj.get("name"),
+            "private": obj.get("private"),
+            "topic": obj.get("topic"),
+            "workspace": obj.get("workspace")
+        })
+        return _obj
+
+

pkg/hanzoai/cloud/models/team_room_bind.py

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+"""
+    Hanzo Cloud API
+
+    The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field, StrictStr
+from typing import Any, ClassVar, Dict, List, Optional
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TeamRoomBind(BaseModel):
+    """
+    TeamRoomBind
+    """ # noqa: E501
+    bindings: Optional[List[StrictStr]] = Field(default=None, description="Bindings REPLACES what the room is about, wholly. It is a replace and not a merge because a caller that cannot remove a binding would have no way to correct a wrong one, and an empty list sent explicitly is how a room is unbound. Absent (null) leaves the existing list alone.")
+    id: Optional[StrictStr] = Field(default=None, description="ID is the room to bind, from the path. The URL is the authority; a body carrying another id cannot redirect the write.")
+    life: Optional[StrictStr] = Field(default=None, description="Life sets the lifecycle intent: \"standing\" or \"bound\". Any other value is refused rather than stored, so a reader never has to interpret a third one. Empty leaves the current intent unchanged.")
+    workspace: Optional[StrictStr] = Field(default=None, description="Workspace names the workspace holding the room. It is required, because a room id is unique only within one and searching every workspace for a matching id would make the write's target depend on iteration order.")
+    __properties: ClassVar[List[str]] = ["bindings", "id", "life", "workspace"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TeamRoomBind from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TeamRoomBind from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "bindings": obj.get("bindings"),
+            "id": obj.get("id"),
+            "life": obj.get("life"),
+            "workspace": obj.get("workspace")
+        })
+        return _obj
+
+

pkg/hanzoai/cloud/models/team_rooms.py

@@ -0,0 +1,95 @@
+# coding: utf-8
+
+"""
+    Hanzo Cloud API
+
+    The Hanzo Cloud API as a customer calls it: every operation under /v1/ except the operator's admin product, relay routes, legacy spellings and capabilities still reached by flag. Tagged by product: the first path segment after /v1/.
+
+    The version of the OpenAPI document: v1
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+from __future__ import annotations
+import pprint
+import re  # noqa: F401
+import json
+
+from pydantic import BaseModel, ConfigDict, Field
+from typing import Any, ClassVar, Dict, List, Optional
+from hanzoai.cloud.models.team_room import TeamRoom
+from typing import Optional, Set
+from typing_extensions import Self
+
+class TeamRooms(BaseModel):
+    """
+    TeamRooms
+    """ # noqa: E501
+    rooms: Optional[List[TeamRoom]] = Field(default=None, description="Rooms is every room of every workspace the caller's org owns, each with the work facet it carries.")
+    __properties: ClassVar[List[str]] = ["rooms"]
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+
+    def to_str(self) -> str:
+        """Returns the string representation of the model using alias"""
+        return pprint.pformat(self.model_dump(by_alias=True))
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the model using alias"""
+        # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead
+        return json.dumps(self.to_dict())
+
+    @classmethod
+    def from_json(cls, json_str: str) -> Optional[Self]:
+        """Create an instance of TeamRooms from a JSON string"""
+        return cls.from_dict(json.loads(json_str))
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Return the dictionary representation of the model using alias.
+
+        This has the following differences from calling pydantic's
+        `self.model_dump(by_alias=True)`:
+
+        * `None` is only added to the output dict for nullable fields that
+          were set at model initialization. Other fields with value `None`
+          are ignored.
+        """
+        excluded_fields: Set[str] = set([
+        ])
+
+        _dict = self.model_dump(
+            by_alias=True,
+            exclude=excluded_fields,
+            exclude_none=True,
+        )
+        # override the default output from pydantic by calling `to_dict()` of each item in rooms (list)
+        _items = []
+        if self.rooms:
+            for _item_rooms in self.rooms:
+                if _item_rooms:
+                    _items.append(_item_rooms.to_dict())
+            _dict['rooms'] = _items
+        return _dict
+
+    @classmethod
+    def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]:
+        """Create an instance of TeamRooms from a dict"""
+        if obj is None:
+            return None
+
+        if not isinstance(obj, dict):
+            return cls.model_validate(obj)
+
+        _obj = cls.model_validate({
+            "rooms": [TeamRoom.from_dict(_item) for _item in obj["rooms"]] if obj.get("rooms") is not None else None
+        })
+        return _obj
+
+

pkg/hanzoai/cloud/models/trust_item_view.py

@@ -32,8 +32,8 @@ class TrustItemView(BaseModel):
     document: Optional[StrictStr] = Field(default=None, description="Document is the data-room document holding its bytes, empty when it has none.")
     framework: Optional[StrictStr] = Field(default=None, description="Framework is the standard it speaks to, when it speaks to one.")
     id: Optional[StrictStr] = Field(default=None, description="ID addresses the item.")
-    kind: Optional[StrictStr] = Field(default=None, description="Kind is what it is.")
-    name: Optional[StrictStr] = Field(default=None, description="Name is its title.")
+    kind: Optional[StrictStr] = Field(default=None, description="Kind is one of report, letter, policy, questionnaire, subprocessor, article or update — the closed set the public centre knows how to draw.")
+    name: Optional[StrictStr] = Field(default=None, description="Name is the label the centre lists it under.")
     retired: Optional[StrictBool] = Field(default=None, description="Retired is whether it has been withdrawn. A retired item is absent from the public centre and cannot be granted; it is kept because a grant already made over it is part of the record.")
     summary: Optional[StrictStr] = Field(default=None, description="Summary is a line about it.")
     tier: Optional[StrictStr] = Field(default=None, description="Tier is public or gated. Gated is the default and an auditor-signed item can only ever be gated.")