nominal-api 0.606.0__py3-none-any.whl → 0.607.0__py3-none-any.whl

nominal_api/_impl.py

@@ -1240,6 +1240,1589 @@ attachments_api_UpdateAttachmentRequest.__qualname__ = "UpdateAttachmentRequest"
 attachments_api_UpdateAttachmentRequest.__module__ = "nominal_api.attachments_api"
 
 
+class authentication_api_AppearanceSetting(ConjureEnumType):
+
+    SYSTEM = 'SYSTEM'
+    '''SYSTEM'''
+    LIGHT = 'LIGHT'
+    '''LIGHT'''
+    DARK = 'DARK'
+    '''DARK'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+authentication_api_AppearanceSetting.__name__ = "AppearanceSetting"
+authentication_api_AppearanceSetting.__qualname__ = "AppearanceSetting"
+authentication_api_AppearanceSetting.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_AuthenticationServiceV2(Service):
+    """
+    This service provides operations for managing user and org profiles/settings.
+Its name is a bit of a misnomer.
+    """
+
+    def get_my_profile(self, auth_header: str) -> "authentication_api_UserV2":
+        """
+        Gets the profile of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/profile'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
+
+    def update_my_profile(self, auth_header: str, update_my_profile_request: "authentication_api_UpdateMyProfileRequest") -> "authentication_api_UserV2":
+        """
+        Updates the profile of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(update_my_profile_request)
+
+        _path = '/authentication/v2/my/profile'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
+
+    def get_my_settings(self, auth_header: str) -> "authentication_api_UserSettings":
+        """
+        Gets the settings of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/my/settings'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_UserSettings, self._return_none_for_unknown_union_types)
+
+    def update_my_settings(self, auth_header: str, user_settings: "authentication_api_UserSettings") -> "authentication_api_UserSettings":
+        """
+        Updates the settings of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(user_settings)
+
+        _path = '/authentication/v2/my/settings'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_UserSettings, self._return_none_for_unknown_union_types)
+
+    def get_my_org_settings(self, auth_header: str) -> "authentication_api_OrgSettings":
+        """
+        Gets the settings of the org of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/org/settings'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_OrgSettings, self._return_none_for_unknown_union_types)
+
+    def update_my_org_settings(self, auth_header: str, org_settings: "authentication_api_OrgSettings") -> "authentication_api_OrgSettings":
+        """
+        Updates the settings of the org of the authenticated user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(org_settings)
+
+        _path = '/authentication/v2/org/settings'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_OrgSettings, self._return_none_for_unknown_union_types)
+
+    def search_users_v2(self, auth_header: str, request: "authentication_api_SearchUsersRequest") -> "authentication_api_SearchUsersResponseV2":
+        """
+        Searches for users by email and displayName.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authentication/v2/users'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_SearchUsersResponseV2, self._return_none_for_unknown_union_types)
+
+    def get_users(self, auth_header: str, user_rids: List[str] = None) -> List["authentication_api_UserV2"]:
+        """
+        Get users by RID.
+        """
+        user_rids = user_rids if user_rids is not None else []
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(user_rids)
+
+        _path = '/authentication/v2/users/batch'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[authentication_api_UserV2], self._return_none_for_unknown_union_types)
+
+    def get_user(self, auth_header: str, user_rid: str) -> "authentication_api_UserV2":
+        """
+        Gets a user by RID.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'userRid': user_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/authentication/v2/users/{userRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authentication_api_UserV2, self._return_none_for_unknown_union_types)
+
+
+authentication_api_AuthenticationServiceV2.__name__ = "AuthenticationServiceV2"
+authentication_api_AuthenticationServiceV2.__qualname__ = "AuthenticationServiceV2"
+authentication_api_AuthenticationServiceV2.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_DefaultTimeRangeTypeSetting(ConjureEnumType):
+
+    DEFAULT = 'DEFAULT'
+    '''DEFAULT'''
+    ABSOLUTE = 'ABSOLUTE'
+    '''ABSOLUTE'''
+    RELATIVE = 'RELATIVE'
+    '''RELATIVE'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+authentication_api_DefaultTimeRangeTypeSetting.__name__ = "DefaultTimeRangeTypeSetting"
+authentication_api_DefaultTimeRangeTypeSetting.__qualname__ = "DefaultTimeRangeTypeSetting"
+authentication_api_DefaultTimeRangeTypeSetting.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_OrgSettings(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'default_time_range_type': ConjureFieldDefinition('defaultTimeRangeType', OptionalTypeWrapper[authentication_api_DefaultTimeRangeTypeSetting])
+        }
+
+    __slots__: List[str] = ['_default_time_range_type']
+
+    def __init__(self, default_time_range_type: Optional["authentication_api_DefaultTimeRangeTypeSetting"] = None) -> None:
+        self._default_time_range_type = default_time_range_type
+
+    @builtins.property
+    def default_time_range_type(self) -> Optional["authentication_api_DefaultTimeRangeTypeSetting"]:
+        return self._default_time_range_type
+
+
+authentication_api_OrgSettings.__name__ = "OrgSettings"
+authentication_api_OrgSettings.__qualname__ = "OrgSettings"
+authentication_api_OrgSettings.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SearchUsersQuery(ConjureUnionType):
+    _and_: Optional[List["authentication_api_SearchUsersQuery"]] = None
+    _or_: Optional[List["authentication_api_SearchUsersQuery"]] = None
+    _exact_match: Optional[str] = None
+    _search_text: Optional[str] = None
+
+    @builtins.classmethod
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'and_': ConjureFieldDefinition('and', List[authentication_api_SearchUsersQuery]),
+            'or_': ConjureFieldDefinition('or', List[authentication_api_SearchUsersQuery]),
+            'exact_match': ConjureFieldDefinition('exactMatch', str),
+            'search_text': ConjureFieldDefinition('searchText', str)
+        }
+
+    def __init__(
+            self,
+            and_: Optional[List["authentication_api_SearchUsersQuery"]] = None,
+            or_: Optional[List["authentication_api_SearchUsersQuery"]] = None,
+            exact_match: Optional[str] = None,
+            search_text: Optional[str] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (and_ is not None) + (or_ is not None) + (exact_match is not None) + (search_text is not None) != 1:
+                raise ValueError('a union must contain a single member')
+
+            if and_ is not None:
+                self._and_ = and_
+                self._type = 'and'
+            if or_ is not None:
+                self._or_ = or_
+                self._type = 'or'
+            if exact_match is not None:
+                self._exact_match = exact_match
+                self._type = 'exactMatch'
+            if search_text is not None:
+                self._search_text = search_text
+                self._type = 'searchText'
+
+        elif type_of_union == 'and':
+            if and_ is None:
+                raise ValueError('a union value must not be None')
+            self._and_ = and_
+            self._type = 'and'
+        elif type_of_union == 'or':
+            if or_ is None:
+                raise ValueError('a union value must not be None')
+            self._or_ = or_
+            self._type = 'or'
+        elif type_of_union == 'exactMatch':
+            if exact_match is None:
+                raise ValueError('a union value must not be None')
+            self._exact_match = exact_match
+            self._type = 'exactMatch'
+        elif type_of_union == 'searchText':
+            if search_text is None:
+                raise ValueError('a union value must not be None')
+            self._search_text = search_text
+            self._type = 'searchText'
+
+    @builtins.property
+    def and_(self) -> Optional[List["authentication_api_SearchUsersQuery"]]:
+        return self._and_
+
+    @builtins.property
+    def or_(self) -> Optional[List["authentication_api_SearchUsersQuery"]]:
+        return self._or_
+
+    @builtins.property
+    def exact_match(self) -> Optional[str]:
+        """
+        Performs case insensitive exact match on email
+        """
+        return self._exact_match
+
+    @builtins.property
+    def search_text(self) -> Optional[str]:
+        """
+        Searches email and display name
+        """
+        return self._search_text
+
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, authentication_api_SearchUsersQueryVisitor):
+            raise ValueError('{} is not an instance of authentication_api_SearchUsersQueryVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'and' and self.and_ is not None:
+            return visitor._and(self.and_)
+        if self._type == 'or' and self.or_ is not None:
+            return visitor._or(self.or_)
+        if self._type == 'exactMatch' and self.exact_match is not None:
+            return visitor._exact_match(self.exact_match)
+        if self._type == 'searchText' and self.search_text is not None:
+            return visitor._search_text(self.search_text)
+
+
+authentication_api_SearchUsersQuery.__name__ = "SearchUsersQuery"
+authentication_api_SearchUsersQuery.__qualname__ = "SearchUsersQuery"
+authentication_api_SearchUsersQuery.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SearchUsersQueryVisitor:
+
+    @abstractmethod
+    def _and(self, and_: List["authentication_api_SearchUsersQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _or(self, or_: List["authentication_api_SearchUsersQuery"]) -> Any:
+        pass
+
+    @abstractmethod
+    def _exact_match(self, exact_match: str) -> Any:
+        pass
+
+    @abstractmethod
+    def _search_text(self, search_text: str) -> Any:
+        pass
+
+
+authentication_api_SearchUsersQueryVisitor.__name__ = "SearchUsersQueryVisitor"
+authentication_api_SearchUsersQueryVisitor.__qualname__ = "SearchUsersQueryVisitor"
+authentication_api_SearchUsersQueryVisitor.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SearchUsersRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'query': ConjureFieldDefinition('query', authentication_api_SearchUsersQuery),
+            'sort_by': ConjureFieldDefinition('sortBy', OptionalTypeWrapper[authentication_api_SortBy]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token]),
+            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_query', '_sort_by', '_next_page_token', '_page_size']
+
+    def __init__(self, query: "authentication_api_SearchUsersQuery", next_page_token: Optional[str] = None, page_size: Optional[int] = None, sort_by: Optional["authentication_api_SortBy"] = None) -> None:
+        self._query = query
+        self._sort_by = sort_by
+        self._next_page_token = next_page_token
+        self._page_size = page_size
+
+    @builtins.property
+    def query(self) -> "authentication_api_SearchUsersQuery":
+        return self._query
+
+    @builtins.property
+    def sort_by(self) -> Optional["authentication_api_SortBy"]:
+        """
+        UPDATED_AT descending by default
+        """
+        return self._sort_by
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+    @builtins.property
+    def page_size(self) -> Optional[int]:
+        """
+        Defaults to 100. Will throw if larger than 1_000.
+        """
+        return self._page_size
+
+
+authentication_api_SearchUsersRequest.__name__ = "SearchUsersRequest"
+authentication_api_SearchUsersRequest.__qualname__ = "SearchUsersRequest"
+authentication_api_SearchUsersRequest.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SearchUsersResponseV2(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'results': ConjureFieldDefinition('results', List[authentication_api_UserV2]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_results', '_next_page_token']
+
+    def __init__(self, results: List["authentication_api_UserV2"], next_page_token: Optional[str] = None) -> None:
+        self._results = results
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def results(self) -> List["authentication_api_UserV2"]:
+        return self._results
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+authentication_api_SearchUsersResponseV2.__name__ = "SearchUsersResponseV2"
+authentication_api_SearchUsersResponseV2.__qualname__ = "SearchUsersResponseV2"
+authentication_api_SearchUsersResponseV2.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SortBy(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'is_descending': ConjureFieldDefinition('isDescending', bool),
+            'field': ConjureFieldDefinition('field', authentication_api_SortByField)
+        }
+
+    __slots__: List[str] = ['_is_descending', '_field']
+
+    def __init__(self, field: "authentication_api_SortByField", is_descending: bool) -> None:
+        self._is_descending = is_descending
+        self._field = field
+
+    @builtins.property
+    def is_descending(self) -> bool:
+        return self._is_descending
+
+    @builtins.property
+    def field(self) -> "authentication_api_SortByField":
+        return self._field
+
+
+authentication_api_SortBy.__name__ = "SortBy"
+authentication_api_SortBy.__qualname__ = "SortBy"
+authentication_api_SortBy.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_SortByField(ConjureEnumType):
+
+    NAME = 'NAME'
+    '''NAME'''
+    EMAIL = 'EMAIL'
+    '''EMAIL'''
+    CREATED_AT = 'CREATED_AT'
+    '''CREATED_AT'''
+    UPDATED_AT = 'UPDATED_AT'
+    '''UPDATED_AT'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+authentication_api_SortByField.__name__ = "SortByField"
+authentication_api_SortByField.__qualname__ = "SortByField"
+authentication_api_SortByField.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_TimezoneSetting(ConjureEnumType):
+
+    LOCAL = 'LOCAL'
+    '''LOCAL'''
+    UTC = 'UTC'
+    '''UTC'''
+    UNKNOWN = 'UNKNOWN'
+    '''UNKNOWN'''
+
+    def __reduce_ex__(self, proto):
+        return self.__class__, (self.name,)
+
+
+authentication_api_TimezoneSetting.__name__ = "TimezoneSetting"
+authentication_api_TimezoneSetting.__qualname__ = "TimezoneSetting"
+authentication_api_TimezoneSetting.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_UpdateMyProfileRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'display_name': ConjureFieldDefinition('displayName', str)
+        }
+
+    __slots__: List[str] = ['_display_name']
+
+    def __init__(self, display_name: str) -> None:
+        self._display_name = display_name
+
+    @builtins.property
+    def display_name(self) -> str:
+        return self._display_name
+
+
+authentication_api_UpdateMyProfileRequest.__name__ = "UpdateMyProfileRequest"
+authentication_api_UpdateMyProfileRequest.__qualname__ = "UpdateMyProfileRequest"
+authentication_api_UpdateMyProfileRequest.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_UserSettings(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'default_time_range_type': ConjureFieldDefinition('defaultTimeRangeType', OptionalTypeWrapper[authentication_api_DefaultTimeRangeTypeSetting]),
+            'appearance': ConjureFieldDefinition('appearance', OptionalTypeWrapper[authentication_api_AppearanceSetting]),
+            'timezone': ConjureFieldDefinition('timezone', OptionalTypeWrapper[authentication_api_TimezoneSetting]),
+            'time_series_hover_tooltip_concise': ConjureFieldDefinition('timeSeriesHoverTooltipConcise', OptionalTypeWrapper[bool])
+        }
+
+    __slots__: List[str] = ['_default_time_range_type', '_appearance', '_timezone', '_time_series_hover_tooltip_concise']
+
+    def __init__(self, appearance: Optional["authentication_api_AppearanceSetting"] = None, default_time_range_type: Optional["authentication_api_DefaultTimeRangeTypeSetting"] = None, time_series_hover_tooltip_concise: Optional[bool] = None, timezone: Optional["authentication_api_TimezoneSetting"] = None) -> None:
+        self._default_time_range_type = default_time_range_type
+        self._appearance = appearance
+        self._timezone = timezone
+        self._time_series_hover_tooltip_concise = time_series_hover_tooltip_concise
+
+    @builtins.property
+    def default_time_range_type(self) -> Optional["authentication_api_DefaultTimeRangeTypeSetting"]:
+        return self._default_time_range_type
+
+    @builtins.property
+    def appearance(self) -> Optional["authentication_api_AppearanceSetting"]:
+        return self._appearance
+
+    @builtins.property
+    def timezone(self) -> Optional["authentication_api_TimezoneSetting"]:
+        return self._timezone
+
+    @builtins.property
+    def time_series_hover_tooltip_concise(self) -> Optional[bool]:
+        return self._time_series_hover_tooltip_concise
+
+
+authentication_api_UserSettings.__name__ = "UserSettings"
+authentication_api_UserSettings.__qualname__ = "UserSettings"
+authentication_api_UserSettings.__module__ = "nominal_api.authentication_api"
+
+
+class authentication_api_UserV2(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', authentication_api_UserRid),
+            'org_rid': ConjureFieldDefinition('orgRid', authentication_api_OrgRid),
+            'email': ConjureFieldDefinition('email', str),
+            'display_name': ConjureFieldDefinition('displayName', str),
+            'avatar_url': ConjureFieldDefinition('avatarUrl', str)
+        }
+
+    __slots__: List[str] = ['_rid', '_org_rid', '_email', '_display_name', '_avatar_url']
+
+    def __init__(self, avatar_url: str, display_name: str, email: str, org_rid: str, rid: str) -> None:
+        self._rid = rid
+        self._org_rid = org_rid
+        self._email = email
+        self._display_name = display_name
+        self._avatar_url = avatar_url
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def org_rid(self) -> str:
+        return self._org_rid
+
+    @builtins.property
+    def email(self) -> str:
+        return self._email
+
+    @builtins.property
+    def display_name(self) -> str:
+        return self._display_name
+
+    @builtins.property
+    def avatar_url(self) -> str:
+        """
+        Avatar URL or a default avatar if the user does not have one.
+        """
+        return self._avatar_url
+
+
+authentication_api_UserV2.__name__ = "UserV2"
+authentication_api_UserV2.__qualname__ = "UserV2"
+authentication_api_UserV2.__module__ = "nominal_api.authentication_api"
+
+
+class authorization_ApiKey(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rid': ConjureFieldDefinition('rid', authorization_ApiKeyRid),
+            'api_key_name': ConjureFieldDefinition('apiKeyName', str),
+            'created_by': ConjureFieldDefinition('createdBy', str),
+            'created_at': ConjureFieldDefinition('createdAt', str),
+            'expires_at': ConjureFieldDefinition('expiresAt', OptionalTypeWrapper[str]),
+            'is_deleted': ConjureFieldDefinition('isDeleted', bool)
+        }
+
+    __slots__: List[str] = ['_rid', '_api_key_name', '_created_by', '_created_at', '_expires_at', '_is_deleted']
+
+    def __init__(self, api_key_name: str, created_at: str, created_by: str, is_deleted: bool, rid: str, expires_at: Optional[str] = None) -> None:
+        self._rid = rid
+        self._api_key_name = api_key_name
+        self._created_by = created_by
+        self._created_at = created_at
+        self._expires_at = expires_at
+        self._is_deleted = is_deleted
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def api_key_name(self) -> str:
+        return self._api_key_name
+
+    @builtins.property
+    def created_by(self) -> str:
+        return self._created_by
+
+    @builtins.property
+    def created_at(self) -> str:
+        return self._created_at
+
+    @builtins.property
+    def expires_at(self) -> Optional[str]:
+        return self._expires_at
+
+    @builtins.property
+    def is_deleted(self) -> bool:
+        return self._is_deleted
+
+
+authorization_ApiKey.__name__ = "ApiKey"
+authorization_ApiKey.__qualname__ = "ApiKey"
+authorization_ApiKey.__module__ = "nominal_api.authorization"
+
+
+class authorization_AuthorizationRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rids': ConjureFieldDefinition('rids', List[str])
+        }
+
+    __slots__: List[str] = ['_rids']
+
+    def __init__(self, rids: List[str]) -> None:
+        self._rids = rids
+
+    @builtins.property
+    def rids(self) -> List[str]:
+        return self._rids
+
+
+authorization_AuthorizationRequest.__name__ = "AuthorizationRequest"
+authorization_AuthorizationRequest.__qualname__ = "AuthorizationRequest"
+authorization_AuthorizationRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_AuthorizationService(Service):
+    """
+    Authorization service manages the permissions for a user
+to access resources.
+    """
+
+    def authorize(self, auth_header: str, request: "authorization_AuthorizationRequest") -> List[str]:
+        """
+        Given a set of resources, returns the set of resources that the
+user is authorized to access.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/authorize'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[str], self._return_none_for_unknown_union_types)
+
+    def batch_get_workspace_for_resource(self, auth_header: str, request: List[str] = None) -> Dict[str, str]:
+        """
+        Given a set of resources, returns the workspace that each resource belongs to. If a user
+is not authorized on the resource, will omit the resource from the response.
+        """
+        request = request if request is not None else []
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/batch-get-workspace-for-resource'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), Dict[str, api_rids_WorkspaceRid], self._return_none_for_unknown_union_types)
+
+    def register(self, auth_header: str, register_request: "authorization_RegistrationRequest") -> None:
+        """
+        Marks a resource as belonging to an organization.
+Will throw if trying to register a resource that already
+belongs to a different organization.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(register_request)
+
+        _path = '/authorization/v1/register'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def register_in_workspace(self, auth_header: str, request: "authorization_RegisterInWorkspaceRequest") -> None:
+        """
+        Marks a set of resources as belonging to a workspace. Either all resources are
+registered or none are.
+If the user is not in the workspace, this will throw.
+If a resource already belongs to a different workspace, this will throw.
+If a resource already belongs to this workspace, this is a no-op.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/register-in-workspace'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def check_admin(self, auth_header: str) -> None:
+        """
+        Given an authenticated session, this endpoint returns a HTTP 204 if the
+authenticated user is an admin and HTTP 403 otherwise.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/authorization/v1/checkAdmin'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+    def is_email_allowed(self, request: "authorization_IsEmailAllowedRequest") -> "authorization_IsEmailAllowedResponse":
+        """
+        Checks if the email is allowed to register.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/is-email-allowed'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_IsEmailAllowedResponse, self._return_none_for_unknown_union_types)
+
+    def get_access_token(self, request: "authorization_GetAccessTokenRequest") -> "authorization_GetAccessTokenResponse":
+        """
+        Provide an OIDC ID and access token to get a Nominal access token,
+suitable for making API requests. Its expiry will match that of the
+input access token, capped at 24h.
+Throws NotAuthorized if either token is invalid or if the OIDC provider
+is not known.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/access-token'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_GetAccessTokenResponse, self._return_none_for_unknown_union_types)
+
+    def create_api_key(self, auth_header: str, request: "authorization_CreateApiKeyRequest") -> "authorization_CreateApiKeyResponse":
+        """
+        Provide a long-lived API key for making API requests.
+The API key is irretrievable after initial creation.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/api-key'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_CreateApiKeyResponse, self._return_none_for_unknown_union_types)
+
+    def list_api_keys_in_org(self, auth_header: str, request: "authorization_ListApiKeyRequest") -> "authorization_ListApiKeyResponse":
+        """
+        List all API keys in the organization.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/api-keys/org'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_ListApiKeyResponse, self._return_none_for_unknown_union_types)
+
+    def list_user_api_keys(self, auth_header: str, request: "authorization_ListApiKeyRequest") -> "authorization_ListApiKeyResponse":
+        """
+        List all API keys for the user.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/authorization/v1/api-keys/user'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_ListApiKeyResponse, self._return_none_for_unknown_union_types)
+
+    def revoke_api_key(self, auth_header: str, rid: str) -> None:
+        """
+        Delete an API key.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'rid': rid,
+        }
+
+        _json: Any = None
+
+        _path = '/authorization/v1/api-key/{rid}/delete'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'PUT',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        return
+
+
+authorization_AuthorizationService.__name__ = "AuthorizationService"
+authorization_AuthorizationService.__qualname__ = "AuthorizationService"
+authorization_AuthorizationService.__module__ = "nominal_api.authorization"
+
+
+class authorization_CreateApiKeyRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'api_key_name': ConjureFieldDefinition('apiKeyName', str),
+            'expires_after_days': ConjureFieldDefinition('expiresAfterDays', OptionalTypeWrapper[int])
+        }
+
+    __slots__: List[str] = ['_api_key_name', '_expires_after_days']
+
+    def __init__(self, api_key_name: str, expires_after_days: Optional[int] = None) -> None:
+        self._api_key_name = api_key_name
+        self._expires_after_days = expires_after_days
+
+    @builtins.property
+    def api_key_name(self) -> str:
+        """
+        The name of the API key to create.
+        """
+        return self._api_key_name
+
+    @builtins.property
+    def expires_after_days(self) -> Optional[int]:
+        """
+        The number of days after which the API key will expire.
+If omitted, the API key will not expire.
+        """
+        return self._expires_after_days
+
+
+authorization_CreateApiKeyRequest.__name__ = "CreateApiKeyRequest"
+authorization_CreateApiKeyRequest.__qualname__ = "CreateApiKeyRequest"
+authorization_CreateApiKeyRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_CreateApiKeyResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'api_key_metadata': ConjureFieldDefinition('apiKeyMetadata', authorization_ApiKey),
+            'api_key_value': ConjureFieldDefinition('apiKeyValue', str)
+        }
+
+    __slots__: List[str] = ['_api_key_metadata', '_api_key_value']
+
+    def __init__(self, api_key_metadata: "authorization_ApiKey", api_key_value: str) -> None:
+        self._api_key_metadata = api_key_metadata
+        self._api_key_value = api_key_value
+
+    @builtins.property
+    def api_key_metadata(self) -> "authorization_ApiKey":
+        return self._api_key_metadata
+
+    @builtins.property
+    def api_key_value(self) -> str:
+        return self._api_key_value
+
+
+authorization_CreateApiKeyResponse.__name__ = "CreateApiKeyResponse"
+authorization_CreateApiKeyResponse.__qualname__ = "CreateApiKeyResponse"
+authorization_CreateApiKeyResponse.__module__ = "nominal_api.authorization"
+
+
+class authorization_GetAccessTokenFromApiKeyRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'api_key_value': ConjureFieldDefinition('apiKeyValue', str)
+        }
+
+    __slots__: List[str] = ['_api_key_value']
+
+    def __init__(self, api_key_value: str) -> None:
+        self._api_key_value = api_key_value
+
+    @builtins.property
+    def api_key_value(self) -> str:
+        return self._api_key_value
+
+
+authorization_GetAccessTokenFromApiKeyRequest.__name__ = "GetAccessTokenFromApiKeyRequest"
+authorization_GetAccessTokenFromApiKeyRequest.__qualname__ = "GetAccessTokenFromApiKeyRequest"
+authorization_GetAccessTokenFromApiKeyRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_GetAccessTokenRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'id_token': ConjureFieldDefinition('idToken', str),
+            'access_token': ConjureFieldDefinition('accessToken', str)
+        }
+
+    __slots__: List[str] = ['_id_token', '_access_token']
+
+    def __init__(self, access_token: str, id_token: str) -> None:
+        self._id_token = id_token
+        self._access_token = access_token
+
+    @builtins.property
+    def id_token(self) -> str:
+        return self._id_token
+
+    @builtins.property
+    def access_token(self) -> str:
+        """
+        The access token's audience must be for the Nominal API.
+        """
+        return self._access_token
+
+
+authorization_GetAccessTokenRequest.__name__ = "GetAccessTokenRequest"
+authorization_GetAccessTokenRequest.__qualname__ = "GetAccessTokenRequest"
+authorization_GetAccessTokenRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_GetAccessTokenResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'access_token': ConjureFieldDefinition('accessToken', str),
+            'expires_at_seconds': ConjureFieldDefinition('expiresAtSeconds', int),
+            'user_uuid': ConjureFieldDefinition('userUuid', str),
+            'org_uuid': ConjureFieldDefinition('orgUuid', str)
+        }
+
+    __slots__: List[str] = ['_access_token', '_expires_at_seconds', '_user_uuid', '_org_uuid']
+
+    def __init__(self, access_token: str, expires_at_seconds: int, org_uuid: str, user_uuid: str) -> None:
+        self._access_token = access_token
+        self._expires_at_seconds = expires_at_seconds
+        self._user_uuid = user_uuid
+        self._org_uuid = org_uuid
+
+    @builtins.property
+    def access_token(self) -> str:
+        return self._access_token
+
+    @builtins.property
+    def expires_at_seconds(self) -> int:
+        return self._expires_at_seconds
+
+    @builtins.property
+    def user_uuid(self) -> str:
+        return self._user_uuid
+
+    @builtins.property
+    def org_uuid(self) -> str:
+        return self._org_uuid
+
+
+authorization_GetAccessTokenResponse.__name__ = "GetAccessTokenResponse"
+authorization_GetAccessTokenResponse.__qualname__ = "GetAccessTokenResponse"
+authorization_GetAccessTokenResponse.__module__ = "nominal_api.authorization"
+
+
+class authorization_InternalApiKeyService(Service):
+    """
+    This internal-only service manages long lived api keys.e
+    """
+
+    def get_access_token_from_api_key_value(self, request: "authorization_GetAccessTokenFromApiKeyRequest") -> "authorization_GetAccessTokenResponse":
+        """
+        Get a Nominal-issued access token from a long-lived API key. Callers should verify that
+their api key is formatted properly (i.e. prefixed with "nominal_api_key") before calling this endpoint.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/api-key-internal/v1/access-token'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), authorization_GetAccessTokenResponse, self._return_none_for_unknown_union_types)
+
+
+authorization_InternalApiKeyService.__name__ = "InternalApiKeyService"
+authorization_InternalApiKeyService.__qualname__ = "InternalApiKeyService"
+authorization_InternalApiKeyService.__module__ = "nominal_api.authorization"
+
+
+class authorization_IsEmailAllowedRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'email': ConjureFieldDefinition('email', str)
+        }
+
+    __slots__: List[str] = ['_email']
+
+    def __init__(self, email: str) -> None:
+        self._email = email
+
+    @builtins.property
+    def email(self) -> str:
+        return self._email
+
+
+authorization_IsEmailAllowedRequest.__name__ = "IsEmailAllowedRequest"
+authorization_IsEmailAllowedRequest.__qualname__ = "IsEmailAllowedRequest"
+authorization_IsEmailAllowedRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_IsEmailAllowedResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'allowed': ConjureFieldDefinition('allowed', bool)
+        }
+
+    __slots__: List[str] = ['_allowed']
+
+    def __init__(self, allowed: bool) -> None:
+        self._allowed = allowed
+
+    @builtins.property
+    def allowed(self) -> bool:
+        return self._allowed
+
+
+authorization_IsEmailAllowedResponse.__name__ = "IsEmailAllowedResponse"
+authorization_IsEmailAllowedResponse.__qualname__ = "IsEmailAllowedResponse"
+authorization_IsEmailAllowedResponse.__module__ = "nominal_api.authorization"
+
+
+class authorization_ListApiKeyRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'include_deleted': ConjureFieldDefinition('includeDeleted', OptionalTypeWrapper[bool]),
+            'include_expired': ConjureFieldDefinition('includeExpired', OptionalTypeWrapper[bool]),
+            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_include_deleted', '_include_expired', '_page_size', '_next_page_token']
+
+    def __init__(self, include_deleted: Optional[bool] = None, include_expired: Optional[bool] = None, next_page_token: Optional[str] = None, page_size: Optional[int] = None) -> None:
+        self._include_deleted = include_deleted
+        self._include_expired = include_expired
+        self._page_size = page_size
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def include_deleted(self) -> Optional[bool]:
+        """
+        If true, include deleted API keys in the response. Defaults to false.
+        """
+        return self._include_deleted
+
+    @builtins.property
+    def include_expired(self) -> Optional[bool]:
+        """
+        If true, include expired API keys in the response. Defaults to false.
+        """
+        return self._include_expired
+
+    @builtins.property
+    def page_size(self) -> Optional[int]:
+        """
+        The maximum number of API keys to return. Defaults to 100.
+        """
+        return self._page_size
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+authorization_ListApiKeyRequest.__name__ = "ListApiKeyRequest"
+authorization_ListApiKeyRequest.__qualname__ = "ListApiKeyRequest"
+authorization_ListApiKeyRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_ListApiKeyResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'api_keys': ConjureFieldDefinition('apiKeys', List[authorization_ApiKey]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[api_Token])
+        }
+
+    __slots__: List[str] = ['_api_keys', '_next_page_token']
+
+    def __init__(self, api_keys: List["authorization_ApiKey"], next_page_token: Optional[str] = None) -> None:
+        self._api_keys = api_keys
+        self._next_page_token = next_page_token
+
+    @builtins.property
+    def api_keys(self) -> List["authorization_ApiKey"]:
+        return self._api_keys
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
+
+
+authorization_ListApiKeyResponse.__name__ = "ListApiKeyResponse"
+authorization_ListApiKeyResponse.__qualname__ = "ListApiKeyResponse"
+authorization_ListApiKeyResponse.__module__ = "nominal_api.authorization"
+
+
+class authorization_RegisterInWorkspaceRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'resource_rids': ConjureFieldDefinition('resourceRids', List[str]),
+            'workspace_rid': ConjureFieldDefinition('workspaceRid', api_rids_WorkspaceRid)
+        }
+
+    __slots__: List[str] = ['_resource_rids', '_workspace_rid']
+
+    def __init__(self, resource_rids: List[str], workspace_rid: str) -> None:
+        self._resource_rids = resource_rids
+        self._workspace_rid = workspace_rid
+
+    @builtins.property
+    def resource_rids(self) -> List[str]:
+        return self._resource_rids
+
+    @builtins.property
+    def workspace_rid(self) -> str:
+        return self._workspace_rid
+
+
+authorization_RegisterInWorkspaceRequest.__name__ = "RegisterInWorkspaceRequest"
+authorization_RegisterInWorkspaceRequest.__qualname__ = "RegisterInWorkspaceRequest"
+authorization_RegisterInWorkspaceRequest.__module__ = "nominal_api.authorization"
+
+
+class authorization_RegistrationRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'rids': ConjureFieldDefinition('rids', List[str]),
+            'organization_rid': ConjureFieldDefinition('organizationRid', OptionalTypeWrapper[str])
+        }
+
+    __slots__: List[str] = ['_rids', '_organization_rid']
+
+    def __init__(self, rids: List[str], organization_rid: Optional[str] = None) -> None:
+        self._rids = rids
+        self._organization_rid = organization_rid
+
+    @builtins.property
+    def rids(self) -> List[str]:
+        return self._rids
+
+    @builtins.property
+    def organization_rid(self) -> Optional[str]:
+        """
+        If omitted, will use the user's organizationRid.
+        """
+        return self._organization_rid
+
+
+authorization_RegistrationRequest.__name__ = "RegistrationRequest"
+authorization_RegistrationRequest.__qualname__ = "RegistrationRequest"
+authorization_RegistrationRequest.__module__ = "nominal_api.authorization"
+
+
 class comments_api_Comment(ConjureBeanType):
 
     @builtins.classmethod
@@ -5005,6 +6588,9 @@ ingest_api_CompleteMultipartUploadResponse.__module__ = "nominal_api.ingest_api"
 
 
 class ingest_api_CsvOpts(ConjureBeanType):
+    """
+    Options for ingesting csv files.  Supported file formats include .csv, .csv.gz
+    """
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
@@ -5955,6 +7541,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
     _mcap_protobuf_timeseries: Optional["ingest_api_McapProtobufTimeseriesOpts"] = None
     _journal_json: Optional["ingest_api_JournalJsonOpts"] = None
     _csv: Optional["ingest_api_CsvOpts"] = None
+    _parquet: Optional["ingest_api_ParquetOpts"] = None
     _video: Optional["ingest_api_VideoOpts"] = None
     _custom: Optional["ingest_api_CustomOpts"] = None
 
@@ -5965,6 +7552,7 @@ class ingest_api_IngestOptions(ConjureUnionType):
             'mcap_protobuf_timeseries': ConjureFieldDefinition('mcapProtobufTimeseries', ingest_api_McapProtobufTimeseriesOpts),
             'journal_json': ConjureFieldDefinition('journalJson', ingest_api_JournalJsonOpts),
             'csv': ConjureFieldDefinition('csv', ingest_api_CsvOpts),
+            'parquet': ConjureFieldDefinition('parquet', ingest_api_ParquetOpts),
             'video': ConjureFieldDefinition('video', ingest_api_VideoOpts),
             'custom': ConjureFieldDefinition('custom', ingest_api_CustomOpts)
         }
@@ -5975,12 +7563,13 @@ class ingest_api_IngestOptions(ConjureUnionType):
             mcap_protobuf_timeseries: Optional["ingest_api_McapProtobufTimeseriesOpts"] = None,
             journal_json: Optional["ingest_api_JournalJsonOpts"] = None,
             csv: Optional["ingest_api_CsvOpts"] = None,
+            parquet: Optional["ingest_api_ParquetOpts"] = None,
             video: Optional["ingest_api_VideoOpts"] = None,
             custom: Optional["ingest_api_CustomOpts"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (video is not None) + (custom is not None) != 1:
+            if (dataflash is not None) + (mcap_protobuf_timeseries is not None) + (journal_json is not None) + (csv is not None) + (parquet is not None) + (video is not None) + (custom is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if dataflash is not None:
@@ -5995,6 +7584,9 @@ class ingest_api_IngestOptions(ConjureUnionType):
             if csv is not None:
                 self._csv = csv
                 self._type = 'csv'
+            if parquet is not None:
+                self._parquet = parquet
+                self._type = 'parquet'
             if video is not None:
                 self._video = video
                 self._type = 'video'
@@ -6022,6 +7614,11 @@ class ingest_api_IngestOptions(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._csv = csv
             self._type = 'csv'
+        elif type_of_union == 'parquet':
+            if parquet is None:
+                raise ValueError('a union value must not be None')
+            self._parquet = parquet
+            self._type = 'parquet'
         elif type_of_union == 'video':
             if video is None:
                 raise ValueError('a union value must not be None')
@@ -6049,6 +7646,10 @@ class ingest_api_IngestOptions(ConjureUnionType):
     def csv(self) -> Optional["ingest_api_CsvOpts"]:
         return self._csv
 
+    @builtins.property
+    def parquet(self) -> Optional["ingest_api_ParquetOpts"]:
+        return self._parquet
+
     @builtins.property
     def video(self) -> Optional["ingest_api_VideoOpts"]:
         return self._video
@@ -6068,6 +7669,8 @@ class ingest_api_IngestOptions(ConjureUnionType):
             return visitor._journal_json(self.journal_json)
         if self._type == 'csv' and self.csv is not None:
             return visitor._csv(self.csv)
+        if self._type == 'parquet' and self.parquet is not None:
+            return visitor._parquet(self.parquet)
         if self._type == 'video' and self.video is not None:
             return visitor._video(self.video)
         if self._type == 'custom' and self.custom is not None:
@@ -6097,6 +7700,10 @@ class ingest_api_IngestOptionsVisitor:
     def _csv(self, csv: "ingest_api_CsvOpts") -> Any:
         pass
 
+    @abstractmethod
+    def _parquet(self, parquet: "ingest_api_ParquetOpts") -> Any:
+        pass
+
     @abstractmethod
     def _video(self, video: "ingest_api_VideoOpts") -> Any:
         pass
@@ -7726,6 +9333,75 @@ ingest_api_NoTimestampManifest.__qualname__ = "NoTimestampManifest"
 ingest_api_NoTimestampManifest.__module__ = "nominal_api.ingest_api"
 
 
+class ingest_api_ParquetOpts(ConjureBeanType):
+    """
+    Options for ingesting parquet files.
+Supported file formats include .parquet, .parquet.gz 
+and archives such as .tar, .tar.gz, and .zip (must set the isArchive flag).
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'source': ConjureFieldDefinition('source', ingest_api_IngestSource),
+            'target': ConjureFieldDefinition('target', ingest_api_DatasetIngestTarget),
+            'timestamp_metadata': ConjureFieldDefinition('timestampMetadata', ingest_api_TimestampMetadata),
+            'channel_prefix': ConjureFieldDefinition('channelPrefix', ingest_api_ChannelPrefix),
+            'tag_keys_from_columns': ConjureFieldDefinition('tagKeysFromColumns', OptionalTypeWrapper[List[api_TagName]]),
+            'additional_file_tags': ConjureFieldDefinition('additionalFileTags', OptionalTypeWrapper[Dict[api_TagName, api_TagValue]]),
+            'is_archive': ConjureFieldDefinition('isArchive', OptionalTypeWrapper[bool])
+        }
+
+    __slots__: List[str] = ['_source', '_target', '_timestamp_metadata', '_channel_prefix', '_tag_keys_from_columns', '_additional_file_tags', '_is_archive']
+
+    def __init__(self, source: "ingest_api_IngestSource", target: "ingest_api_DatasetIngestTarget", timestamp_metadata: "ingest_api_TimestampMetadata", additional_file_tags: Optional[Dict[str, str]] = None, channel_prefix: Optional[str] = None, is_archive: Optional[bool] = None, tag_keys_from_columns: Optional[List[str]] = None) -> None:
+        self._source = source
+        self._target = target
+        self._timestamp_metadata = timestamp_metadata
+        self._channel_prefix = channel_prefix
+        self._tag_keys_from_columns = tag_keys_from_columns
+        self._additional_file_tags = additional_file_tags
+        self._is_archive = is_archive
+
+    @builtins.property
+    def source(self) -> "ingest_api_IngestSource":
+        return self._source
+
+    @builtins.property
+    def target(self) -> "ingest_api_DatasetIngestTarget":
+        return self._target
+
+    @builtins.property
+    def timestamp_metadata(self) -> "ingest_api_TimestampMetadata":
+        return self._timestamp_metadata
+
+    @builtins.property
+    def channel_prefix(self) -> Optional[str]:
+        return self._channel_prefix
+
+    @builtins.property
+    def tag_keys_from_columns(self) -> Optional[List[str]]:
+        return self._tag_keys_from_columns
+
+    @builtins.property
+    def additional_file_tags(self) -> Optional[Dict[str, str]]:
+        return self._additional_file_tags
+
+    @builtins.property
+    def is_archive(self) -> Optional[bool]:
+        """
+        If true, the file is an archive. Supported archive formats include
+.tar, .tar.gz, and .zip. Only files ending in .parquet
+within the archive will be ingested. If field not provided, defaults to false.
+        """
+        return self._is_archive
+
+
+ingest_api_ParquetOpts.__name__ = "ParquetOpts"
+ingest_api_ParquetOpts.__qualname__ = "ParquetOpts"
+ingest_api_ParquetOpts.__module__ = "nominal_api.ingest_api"
+
+
 class ingest_api_Part(ConjureBeanType):
 
     @builtins.classmethod
@@ -20637,28 +22313,18 @@ class scout_checklistexecution_api_BatchChecklistLiveStatusRequest(ConjureBeanTy
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'requests': ConjureFieldDefinition('requests', List[scout_checklistexecution_api_ChecklistLiveStatusRequest]),
-            'computation_range': ConjureFieldDefinition('computationRange', OptionalTypeWrapper[scout_checklistexecution_api_ComputationRange])
+            'requests': ConjureFieldDefinition('requests', List[scout_checklistexecution_api_ChecklistLiveStatusRequest])
         }
 
-    __slots__: List[str] = ['_requests', '_computation_range']
+    __slots__: List[str] = ['_requests']
 
-    def __init__(self, requests: List["scout_checklistexecution_api_ChecklistLiveStatusRequest"], computation_range: Optional["scout_checklistexecution_api_ComputationRange"] = None) -> None:
+    def __init__(self, requests: List["scout_checklistexecution_api_ChecklistLiveStatusRequest"]) -> None:
         self._requests = requests
-        self._computation_range = computation_range
 
     @builtins.property
     def requests(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusRequest"]:
         return self._requests
 
-    @builtins.property
-    def computation_range(self) -> Optional["scout_checklistexecution_api_ComputationRange"]:
-        """
-        The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results. If not specified, defaults to evaluating from now minus sixty minutes to now.
-        """
-        return self._computation_range
-
 
 scout_checklistexecution_api_BatchChecklistLiveStatusRequest.__name__ = "BatchChecklistLiveStatusRequest"
 scout_checklistexecution_api_BatchChecklistLiveStatusRequest.__qualname__ = "BatchChecklistLiveStatusRequest"
@@ -20670,27 +22336,17 @@ class scout_checklistexecution_api_BatchChecklistLiveStatusResponse(ConjureBeanT
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'computation_range': ConjureFieldDefinition('computationRange', scout_checklistexecution_api_ComputationRange),
-            'checklist_results': ConjureFieldDefinition('checklistResults', List[scout_checklistexecution_api_ChecklistLiveStatusResponse])
+            'checklist_live_status_responses': ConjureFieldDefinition('checklistLiveStatusResponses', List[scout_checklistexecution_api_ChecklistLiveStatusResponse])
         }
 
-    __slots__: List[str] = ['_computation_range', '_checklist_results']
-
-    def __init__(self, checklist_results: List["scout_checklistexecution_api_ChecklistLiveStatusResponse"], computation_range: "scout_checklistexecution_api_ComputationRange") -> None:
-        self._computation_range = computation_range
-        self._checklist_results = checklist_results
+    __slots__: List[str] = ['_checklist_live_status_responses']
 
-    @builtins.property
-    def computation_range(self) -> "scout_checklistexecution_api_ComputationRange":
-        """
-        The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results.
-        """
-        return self._computation_range
+    def __init__(self, checklist_live_status_responses: List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]) -> None:
+        self._checklist_live_status_responses = checklist_live_status_responses
 
     @builtins.property
-    def checklist_results(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]:
-        return self._checklist_results
+    def checklist_live_status_responses(self) -> List["scout_checklistexecution_api_ChecklistLiveStatusResponse"]:
+        return self._checklist_live_status_responses
 
 
 scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__name__ = "BatchChecklistLiveStatusResponse"
@@ -20698,6 +22354,52 @@ scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__qualname__ = "Ba
 scout_checklistexecution_api_BatchChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_BatchGetStreamingChecklistRequest(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'checklist_rids': ConjureFieldDefinition('checklistRids', List[scout_rids_api_ChecklistRid])
+        }
+
+    __slots__: List[str] = ['_checklist_rids']
+
+    def __init__(self, checklist_rids: List[str]) -> None:
+        self._checklist_rids = checklist_rids
+
+    @builtins.property
+    def checklist_rids(self) -> List[str]:
+        return self._checklist_rids
+
+
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__name__ = "BatchGetStreamingChecklistRequest"
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__qualname__ = "BatchGetStreamingChecklistRequest"
+scout_checklistexecution_api_BatchGetStreamingChecklistRequest.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_BatchGetStreamingChecklistResponse(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'streaming_checklist_infos': ConjureFieldDefinition('streamingChecklistInfos', Dict[scout_rids_api_ChecklistRid, scout_checklistexecution_api_StreamingChecklistInfo])
+        }
+
+    __slots__: List[str] = ['_streaming_checklist_infos']
+
+    def __init__(self, streaming_checklist_infos: Dict[str, "scout_checklistexecution_api_StreamingChecklistInfo"]) -> None:
+        self._streaming_checklist_infos = streaming_checklist_infos
+
+    @builtins.property
+    def streaming_checklist_infos(self) -> Dict[str, "scout_checklistexecution_api_StreamingChecklistInfo"]:
+        return self._streaming_checklist_infos
+
+
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__name__ = "BatchGetStreamingChecklistResponse"
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__qualname__ = "BatchGetStreamingChecklistResponse"
+scout_checklistexecution_api_BatchGetStreamingChecklistResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_BatchValidateChecklistResolutionRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -20796,33 +22498,33 @@ class scout_checklistexecution_api_CheckLiveStatusResponse(ConjureBeanType):
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'result': ConjureFieldDefinition('result', scout_checklistexecution_api_CheckLiveStatusResult),
+            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_CheckStatus),
             'check_rid': ConjureFieldDefinition('checkRid', scout_rids_api_CheckRid),
-            'check_implementation_index': ConjureFieldDefinition('checkImplementationIndex', OptionalTypeWrapper[int])
+            'check_parameter_index': ConjureFieldDefinition('checkParameterIndex', OptionalTypeWrapper[int])
         }
 
-    __slots__: List[str] = ['_result', '_check_rid', '_check_implementation_index']
+    __slots__: List[str] = ['_status', '_check_rid', '_check_parameter_index']
 
-    def __init__(self, check_rid: str, result: "scout_checklistexecution_api_CheckLiveStatusResult", check_implementation_index: Optional[int] = None) -> None:
-        self._result = result
+    def __init__(self, check_rid: str, status: "scout_checklistexecution_api_CheckStatus", check_parameter_index: Optional[int] = None) -> None:
+        self._status = status
         self._check_rid = check_rid
-        self._check_implementation_index = check_implementation_index
+        self._check_parameter_index = check_parameter_index
 
     @builtins.property
-    def result(self) -> "scout_checklistexecution_api_CheckLiveStatusResult":
-        return self._result
+    def status(self) -> "scout_checklistexecution_api_CheckStatus":
+        return self._status
 
     @builtins.property
     def check_rid(self) -> str:
         return self._check_rid
 
     @builtins.property
-    def check_implementation_index(self) -> Optional[int]:
+    def check_parameter_index(self) -> Optional[int]:
         """
         Checks can define a single range computation which can evaluate over multiple implementations of a context.
 The check implementation index will correspond to the implementation index of the check condition.
         """
-        return self._check_implementation_index
+        return self._check_parameter_index
 
 
 scout_checklistexecution_api_CheckLiveStatusResponse.__name__ = "CheckLiveStatusResponse"
@@ -20830,130 +22532,31 @@ scout_checklistexecution_api_CheckLiveStatusResponse.__qualname__ = "CheckLiveSt
 scout_checklistexecution_api_CheckLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_CheckLiveStatusResult(ConjureUnionType):
-    _computed: Optional["scout_checklistexecution_api_ComputedResult"] = None
-    _not_computable: Optional["scout_checklistexecution_api_NotComputable"] = None
-    _failed_to_resolve: Optional["scout_checklistexecution_api_FailedToResolve"] = None
-
-    @builtins.classmethod
-    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'computed': ConjureFieldDefinition('computed', scout_checklistexecution_api_ComputedResult),
-            'not_computable': ConjureFieldDefinition('notComputable', scout_checklistexecution_api_NotComputable),
-            'failed_to_resolve': ConjureFieldDefinition('failedToResolve', scout_checklistexecution_api_FailedToResolve)
-        }
-
-    def __init__(
-            self,
-            computed: Optional["scout_checklistexecution_api_ComputedResult"] = None,
-            not_computable: Optional["scout_checklistexecution_api_NotComputable"] = None,
-            failed_to_resolve: Optional["scout_checklistexecution_api_FailedToResolve"] = None,
-            type_of_union: Optional[str] = None
-            ) -> None:
-        if type_of_union is None:
-            if (computed is not None) + (not_computable is not None) + (failed_to_resolve is not None) != 1:
-                raise ValueError('a union must contain a single member')
-
-            if computed is not None:
-                self._computed = computed
-                self._type = 'computed'
-            if not_computable is not None:
-                self._not_computable = not_computable
-                self._type = 'notComputable'
-            if failed_to_resolve is not None:
-                self._failed_to_resolve = failed_to_resolve
-                self._type = 'failedToResolve'
-
-        elif type_of_union == 'computed':
-            if computed is None:
-                raise ValueError('a union value must not be None')
-            self._computed = computed
-            self._type = 'computed'
-        elif type_of_union == 'notComputable':
-            if not_computable is None:
-                raise ValueError('a union value must not be None')
-            self._not_computable = not_computable
-            self._type = 'notComputable'
-        elif type_of_union == 'failedToResolve':
-            if failed_to_resolve is None:
-                raise ValueError('a union value must not be None')
-            self._failed_to_resolve = failed_to_resolve
-            self._type = 'failedToResolve'
-
-    @builtins.property
-    def computed(self) -> Optional["scout_checklistexecution_api_ComputedResult"]:
-        return self._computed
-
-    @builtins.property
-    def not_computable(self) -> Optional["scout_checklistexecution_api_NotComputable"]:
-        """
-        The check cannot be computed in a streaming context. This would be returned if an overly expensive
-computation was attempted, such as checking the rolling median over the last year of data.
-        """
-        return self._not_computable
-
-    @builtins.property
-    def failed_to_resolve(self) -> Optional["scout_checklistexecution_api_FailedToResolve"]:
-        """
-        The checklist cannot be applied to the data sources.
-        """
-        return self._failed_to_resolve
-
-    def accept(self, visitor) -> Any:
-        if not isinstance(visitor, scout_checklistexecution_api_CheckLiveStatusResultVisitor):
-            raise ValueError('{} is not an instance of scout_checklistexecution_api_CheckLiveStatusResultVisitor'.format(visitor.__class__.__name__))
-        if self._type == 'computed' and self.computed is not None:
-            return visitor._computed(self.computed)
-        if self._type == 'notComputable' and self.not_computable is not None:
-            return visitor._not_computable(self.not_computable)
-        if self._type == 'failedToResolve' and self.failed_to_resolve is not None:
-            return visitor._failed_to_resolve(self.failed_to_resolve)
-
-
-scout_checklistexecution_api_CheckLiveStatusResult.__name__ = "CheckLiveStatusResult"
-scout_checklistexecution_api_CheckLiveStatusResult.__qualname__ = "CheckLiveStatusResult"
-scout_checklistexecution_api_CheckLiveStatusResult.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
-class scout_checklistexecution_api_CheckLiveStatusResultVisitor:
-
-    @abstractmethod
-    def _computed(self, computed: "scout_checklistexecution_api_ComputedResult") -> Any:
-        pass
-
-    @abstractmethod
-    def _not_computable(self, not_computable: "scout_checklistexecution_api_NotComputable") -> Any:
-        pass
-
-    @abstractmethod
-    def _failed_to_resolve(self, failed_to_resolve: "scout_checklistexecution_api_FailedToResolve") -> Any:
-        pass
-
-
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__name__ = "CheckLiveStatusResultVisitor"
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__qualname__ = "CheckLiveStatusResultVisitor"
-scout_checklistexecution_api_CheckLiveStatusResultVisitor.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
 class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
     _pass_: Optional["scout_checklistexecution_api_Pass"] = None
     _fail: Optional["scout_checklistexecution_api_Fail"] = None
+    _invalid: Optional["scout_checklistexecution_api_Invalid"] = None
+    _skipped: Optional["scout_checklistexecution_api_Skipped"] = None
 
     @builtins.classmethod
     def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
             'pass_': ConjureFieldDefinition('pass', scout_checklistexecution_api_Pass),
-            'fail': ConjureFieldDefinition('fail', scout_checklistexecution_api_Fail)
+            'fail': ConjureFieldDefinition('fail', scout_checklistexecution_api_Fail),
+            'invalid': ConjureFieldDefinition('invalid', scout_checklistexecution_api_Invalid),
+            'skipped': ConjureFieldDefinition('skipped', scout_checklistexecution_api_Skipped)
         }
 
     def __init__(
             self,
             pass_: Optional["scout_checklistexecution_api_Pass"] = None,
             fail: Optional["scout_checklistexecution_api_Fail"] = None,
+            invalid: Optional["scout_checklistexecution_api_Invalid"] = None,
+            skipped: Optional["scout_checklistexecution_api_Skipped"] = None,
             type_of_union: Optional[str] = None
             ) -> None:
         if type_of_union is None:
-            if (pass_ is not None) + (fail is not None) != 1:
+            if (pass_ is not None) + (fail is not None) + (invalid is not None) + (skipped is not None) != 1:
                 raise ValueError('a union must contain a single member')
 
             if pass_ is not None:
@@ -20962,6 +22565,12 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
             if fail is not None:
                 self._fail = fail
                 self._type = 'fail'
+            if invalid is not None:
+                self._invalid = invalid
+                self._type = 'invalid'
+            if skipped is not None:
+                self._skipped = skipped
+                self._type = 'skipped'
 
         elif type_of_union == 'pass':
             if pass_ is None:
@@ -20973,6 +22582,16 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
                 raise ValueError('a union value must not be None')
             self._fail = fail
             self._type = 'fail'
+        elif type_of_union == 'invalid':
+            if invalid is None:
+                raise ValueError('a union value must not be None')
+            self._invalid = invalid
+            self._type = 'invalid'
+        elif type_of_union == 'skipped':
+            if skipped is None:
+                raise ValueError('a union value must not be None')
+            self._skipped = skipped
+            self._type = 'skipped'
 
     @builtins.property
     def pass_(self) -> Optional["scout_checklistexecution_api_Pass"]:
@@ -20988,6 +22607,24 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
         """
         return self._fail
 
+    @builtins.property
+    def invalid(self) -> Optional["scout_checklistexecution_api_Invalid"]:
+        """
+        The check was evaluated and is currently in state INVALID.
+This signifies that the check could not be evaluated due to an internal error or
+if an overly expensive computation was attempted.
+        """
+        return self._invalid
+
+    @builtins.property
+    def skipped(self) -> Optional["scout_checklistexecution_api_Skipped"]:
+        """
+        The check was skipped and was not evaluated.
+This typically occurs when the check performs operations that are not supported in the streaming context,
+or if the required channels could not be resolved.
+        """
+        return self._skipped
+
     def accept(self, visitor) -> Any:
         if not isinstance(visitor, scout_checklistexecution_api_CheckStatusVisitor):
             raise ValueError('{} is not an instance of scout_checklistexecution_api_CheckStatusVisitor'.format(visitor.__class__.__name__))
@@ -20995,6 +22632,10 @@ class scout_checklistexecution_api_CheckStatus(ConjureUnionType):
             return visitor._pass(self.pass_)
         if self._type == 'fail' and self.fail is not None:
             return visitor._fail(self.fail)
+        if self._type == 'invalid' and self.invalid is not None:
+            return visitor._invalid(self.invalid)
+        if self._type == 'skipped' and self.skipped is not None:
+            return visitor._skipped(self.skipped)
 
 
 scout_checklistexecution_api_CheckStatus.__name__ = "CheckStatus"
@@ -21012,6 +22653,14 @@ class scout_checklistexecution_api_CheckStatusVisitor:
     def _fail(self, fail: "scout_checklistexecution_api_Fail") -> Any:
         pass
 
+    @abstractmethod
+    def _invalid(self, invalid: "scout_checklistexecution_api_Invalid") -> Any:
+        pass
+
+    @abstractmethod
+    def _skipped(self, skipped: "scout_checklistexecution_api_Skipped") -> Any:
+        pass
+
 
 scout_checklistexecution_api_CheckStatusVisitor.__name__ = "CheckStatusVisitor"
 scout_checklistexecution_api_CheckStatusVisitor.__qualname__ = "CheckStatusVisitor"
@@ -21025,8 +22674,7 @@ class scout_checklistexecution_api_ChecklistExecutionService(Service):
 
     def checklist_live_status(self, auth_header: str, request: "scout_checklistexecution_api_BatchChecklistLiveStatusRequest") -> "scout_checklistexecution_api_BatchChecklistLiveStatusResponse":
         """
-        For each request, get the current status and last failing time (if possible) for
-every automatic check against the given run.
+        For each request, get the latest status for each check in a streaming checklist against the given asset.
         """
 
         _headers: Dict[str, Any] = {
@@ -21058,8 +22706,8 @@ every automatic check against the given run.
 
     def execute_streaming_checklist(self, auth_header: str, request: "scout_checklistexecution_api_ExecuteChecklistForAssetsRequest") -> None:
         """
-        Triggers a checklist to run continuously against assets. Returns a ChecklistAlreadyRunning error if the
-checklist is already running for the given asset.
+        Triggers a checklist to run continuously against assets.
+If the checklist is already running for the given asset, replace the existing configuration with the one specified by the request.
         """
 
         _headers: Dict[str, Any] = {
@@ -21154,7 +22802,7 @@ checklist is already running for the given asset.
 
     def get_streaming_checklist(self, auth_header: str, checklist_rid: str) -> "scout_checklistexecution_api_StreamingChecklistInfo":
         """
-        Retrieves information about a streaming checklist using the provided checklistRid.
+        Retrieves the set of assets and their execution configurations for a streaming checklist specified by the checklistRid.
         """
 
         _headers: Dict[str, Any] = {
@@ -21184,6 +22832,39 @@ checklist is already running for the given asset.
         _decoder = ConjureDecoder()
         return _decoder.decode(_response.json(), scout_checklistexecution_api_StreamingChecklistInfo, self._return_none_for_unknown_union_types)
 
+    def batch_get_streaming_checklist(self, auth_header: str, request: "scout_checklistexecution_api_BatchGetStreamingChecklistRequest") -> "scout_checklistexecution_api_BatchGetStreamingChecklistResponse":
+        """
+        Retrieves the set of assets and their execution configurations for all streaming checklists specified by the request.
+If a streaming checklist is not found, it will not be included in the response.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Content-Type': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = ConjureEncoder().default(request)
+
+        _path = '/scout/v2/checklist-execution/get-streaming-checklists'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'POST',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), scout_checklistexecution_api_BatchGetStreamingChecklistResponse, self._return_none_for_unknown_union_types)
+
     def stop_streaming_checklist(self, auth_header: str, checklist_rid: str) -> None:
         """
         Stops the execution of a streaming checklist on all assets.
@@ -21315,147 +22996,175 @@ scout_checklistexecution_api_ChecklistExecutionService.__qualname__ = "Checklist
 scout_checklistexecution_api_ChecklistExecutionService.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ChecklistLiveStatusRequest(ConjureBeanType):
-    """
-    If commit is not provided, the latest commit on main will be used. At least one of runRid or assetRid must be provided, but not both.
-    """
+class scout_checklistexecution_api_ChecklistLiveStatus(ConjureUnionType):
+    _running: Optional["scout_checklistexecution_api_StreamingChecklistRunning"] = None
+    _initializing: Optional["scout_checklistexecution_api_StreamingChecklistInitializing"] = None
+    _failed: Optional["scout_checklistexecution_api_StreamingChecklistFailed"] = None
 
     @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+    def _options(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
-            'commit': ConjureFieldDefinition('commit', OptionalTypeWrapper[scout_versioning_api_CommitId]),
-            'run_rid': ConjureFieldDefinition('runRid', OptionalTypeWrapper[scout_run_api_RunRid]),
-            'asset_rid': ConjureFieldDefinition('assetRid', OptionalTypeWrapper[scout_rids_api_AssetRid])
+            'running': ConjureFieldDefinition('running', scout_checklistexecution_api_StreamingChecklistRunning),
+            'initializing': ConjureFieldDefinition('initializing', scout_checklistexecution_api_StreamingChecklistInitializing),
+            'failed': ConjureFieldDefinition('failed', scout_checklistexecution_api_StreamingChecklistFailed)
         }
 
-    __slots__: List[str] = ['_checklist_rid', '_commit', '_run_rid', '_asset_rid']
+    def __init__(
+            self,
+            running: Optional["scout_checklistexecution_api_StreamingChecklistRunning"] = None,
+            initializing: Optional["scout_checklistexecution_api_StreamingChecklistInitializing"] = None,
+            failed: Optional["scout_checklistexecution_api_StreamingChecklistFailed"] = None,
+            type_of_union: Optional[str] = None
+            ) -> None:
+        if type_of_union is None:
+            if (running is not None) + (initializing is not None) + (failed is not None) != 1:
+                raise ValueError('a union must contain a single member')
 
-    def __init__(self, checklist_rid: str, asset_rid: Optional[str] = None, commit: Optional[str] = None, run_rid: Optional[str] = None) -> None:
-        self._checklist_rid = checklist_rid
-        self._commit = commit
-        self._run_rid = run_rid
-        self._asset_rid = asset_rid
+            if running is not None:
+                self._running = running
+                self._type = 'running'
+            if initializing is not None:
+                self._initializing = initializing
+                self._type = 'initializing'
+            if failed is not None:
+                self._failed = failed
+                self._type = 'failed'
 
-    @builtins.property
-    def checklist_rid(self) -> str:
-        return self._checklist_rid
+        elif type_of_union == 'running':
+            if running is None:
+                raise ValueError('a union value must not be None')
+            self._running = running
+            self._type = 'running'
+        elif type_of_union == 'initializing':
+            if initializing is None:
+                raise ValueError('a union value must not be None')
+            self._initializing = initializing
+            self._type = 'initializing'
+        elif type_of_union == 'failed':
+            if failed is None:
+                raise ValueError('a union value must not be None')
+            self._failed = failed
+            self._type = 'failed'
 
     @builtins.property
-    def commit(self) -> Optional[str]:
-        return self._commit
+    def running(self) -> Optional["scout_checklistexecution_api_StreamingChecklistRunning"]:
+        """
+        The streaming checklist is currently executing against the asset.
+        """
+        return self._running
 
     @builtins.property
-    def run_rid(self) -> Optional[str]:
-        return self._run_rid
+    def initializing(self) -> Optional["scout_checklistexecution_api_StreamingChecklistInitializing"]:
+        """
+        The streaming checklist is currently initializing against the asset.
+        """
+        return self._initializing
 
     @builtins.property
-    def asset_rid(self) -> Optional[str]:
-        return self._asset_rid
-
+    def failed(self) -> Optional["scout_checklistexecution_api_StreamingChecklistFailed"]:
+        """
+        The streaming checklist failed unexpectedly. Please contact support.
+        """
+        return self._failed
 
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__name__ = "ChecklistLiveStatusRequest"
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__qualname__ = "ChecklistLiveStatusRequest"
-scout_checklistexecution_api_ChecklistLiveStatusRequest.__module__ = "nominal_api.scout_checklistexecution_api"
+    def accept(self, visitor) -> Any:
+        if not isinstance(visitor, scout_checklistexecution_api_ChecklistLiveStatusVisitor):
+            raise ValueError('{} is not an instance of scout_checklistexecution_api_ChecklistLiveStatusVisitor'.format(visitor.__class__.__name__))
+        if self._type == 'running' and self.running is not None:
+            return visitor._running(self.running)
+        if self._type == 'initializing' and self.initializing is not None:
+            return visitor._initializing(self.initializing)
+        if self._type == 'failed' and self.failed is not None:
+            return visitor._failed(self.failed)
 
 
-class scout_checklistexecution_api_ChecklistLiveStatusResponse(ConjureBeanType):
+scout_checklistexecution_api_ChecklistLiveStatus.__name__ = "ChecklistLiveStatus"
+scout_checklistexecution_api_ChecklistLiveStatus.__qualname__ = "ChecklistLiveStatus"
+scout_checklistexecution_api_ChecklistLiveStatus.__module__ = "nominal_api.scout_checklistexecution_api"
 
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
-            'check_results': ConjureFieldDefinition('checkResults', List[scout_checklistexecution_api_CheckLiveStatusResponse])
-        }
 
-    __slots__: List[str] = ['_checklist_rid', '_check_results']
+class scout_checklistexecution_api_ChecklistLiveStatusVisitor:
 
-    def __init__(self, check_results: List["scout_checklistexecution_api_CheckLiveStatusResponse"], checklist_rid: str) -> None:
-        self._checklist_rid = checklist_rid
-        self._check_results = check_results
+    @abstractmethod
+    def _running(self, running: "scout_checklistexecution_api_StreamingChecklistRunning") -> Any:
+        pass
 
-    @builtins.property
-    def checklist_rid(self) -> str:
-        return self._checklist_rid
+    @abstractmethod
+    def _initializing(self, initializing: "scout_checklistexecution_api_StreamingChecklistInitializing") -> Any:
+        pass
 
-    @builtins.property
-    def check_results(self) -> List["scout_checklistexecution_api_CheckLiveStatusResponse"]:
-        return self._check_results
+    @abstractmethod
+    def _failed(self, failed: "scout_checklistexecution_api_StreamingChecklistFailed") -> Any:
+        pass
 
 
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__name__ = "ChecklistLiveStatusResponse"
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__qualname__ = "ChecklistLiveStatusResponse"
-scout_checklistexecution_api_ChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__name__ = "ChecklistLiveStatusVisitor"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__qualname__ = "ChecklistLiveStatusVisitor"
+scout_checklistexecution_api_ChecklistLiveStatusVisitor.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ComputationRange(ConjureBeanType):
-    """
-    The time range over which status and last failure were calculated. Failures outside of this time range
-will not be included in the results.
-    """
+class scout_checklistexecution_api_ChecklistLiveStatusRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'start': ConjureFieldDefinition('start', api_Timestamp),
-            'end': ConjureFieldDefinition('end', api_Timestamp)
+            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid)
         }
 
-    __slots__: List[str] = ['_start', '_end']
+    __slots__: List[str] = ['_checklist_rid', '_asset_rid']
 
-    def __init__(self, end: "api_Timestamp", start: "api_Timestamp") -> None:
-        self._start = start
-        self._end = end
+    def __init__(self, asset_rid: str, checklist_rid: str) -> None:
+        self._checklist_rid = checklist_rid
+        self._asset_rid = asset_rid
 
     @builtins.property
-    def start(self) -> "api_Timestamp":
-        return self._start
+    def checklist_rid(self) -> str:
+        return self._checklist_rid
 
     @builtins.property
-    def end(self) -> "api_Timestamp":
-        return self._end
+    def asset_rid(self) -> str:
+        return self._asset_rid
 
 
-scout_checklistexecution_api_ComputationRange.__name__ = "ComputationRange"
-scout_checklistexecution_api_ComputationRange.__qualname__ = "ComputationRange"
-scout_checklistexecution_api_ComputationRange.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__name__ = "ChecklistLiveStatusRequest"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__qualname__ = "ChecklistLiveStatusRequest"
+scout_checklistexecution_api_ChecklistLiveStatusRequest.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_ComputedResult(ConjureBeanType):
+class scout_checklistexecution_api_ChecklistLiveStatusResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_CheckStatus),
-            'last_failure': ConjureFieldDefinition('lastFailure', scout_checklistexecution_api_LastFailure)
+            'checklist_rid': ConjureFieldDefinition('checklistRid', scout_rids_api_ChecklistRid),
+            'asset_rid': ConjureFieldDefinition('assetRid', scout_rids_api_AssetRid),
+            'status': ConjureFieldDefinition('status', scout_checklistexecution_api_ChecklistLiveStatus)
         }
 
-    __slots__: List[str] = ['_status', '_last_failure']
+    __slots__: List[str] = ['_checklist_rid', '_asset_rid', '_status']
 
-    def __init__(self, last_failure: "scout_checklistexecution_api_LastFailure", status: "scout_checklistexecution_api_CheckStatus") -> None:
+    def __init__(self, asset_rid: str, checklist_rid: str, status: "scout_checklistexecution_api_ChecklistLiveStatus") -> None:
+        self._checklist_rid = checklist_rid
+        self._asset_rid = asset_rid
         self._status = status
-        self._last_failure = last_failure
 
     @builtins.property
-    def status(self) -> "scout_checklistexecution_api_CheckStatus":
-        """
-        The current status of a check at the time it was evaluated.
-        """
-        return self._status
+    def checklist_rid(self) -> str:
+        return self._checklist_rid
 
     @builtins.property
-    def last_failure(self) -> "scout_checklistexecution_api_LastFailure":
-        """
-        If computed, represents the last time the check failed.
-Can also represent that the last failure hasn't been computed, or is currently being computed.
-If the check is currently failing, the current failure is returned.
-        """
-        return self._last_failure
+    def asset_rid(self) -> str:
+        return self._asset_rid
+
+    @builtins.property
+    def status(self) -> "scout_checklistexecution_api_ChecklistLiveStatus":
+        return self._status
 
 
-scout_checklistexecution_api_ComputedResult.__name__ = "ComputedResult"
-scout_checklistexecution_api_ComputedResult.__qualname__ = "ComputedResult"
-scout_checklistexecution_api_ComputedResult.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__name__ = "ChecklistLiveStatusResponse"
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__qualname__ = "ChecklistLiveStatusResponse"
+scout_checklistexecution_api_ChecklistLiveStatusResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
 class scout_checklistexecution_api_Computing(ConjureBeanType):
@@ -21550,35 +23259,6 @@ scout_checklistexecution_api_Fail.__qualname__ = "Fail"
 scout_checklistexecution_api_Fail.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_FailedToResolve(ConjureBeanType):
-    """
-    The checklist cannot be applied to the data sources.
-    """
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'variable_name': ConjureFieldDefinition('variableName', str)
-        }
-
-    __slots__: List[str] = ['_variable_name']
-
-    def __init__(self, variable_name: str) -> None:
-        self._variable_name = variable_name
-
-    @builtins.property
-    def variable_name(self) -> str:
-        """
-        The variable name that couldn't be resolved to a series.
-        """
-        return self._variable_name
-
-
-scout_checklistexecution_api_FailedToResolve.__name__ = "FailedToResolve"
-scout_checklistexecution_api_FailedToResolve.__qualname__ = "FailedToResolve"
-scout_checklistexecution_api_FailedToResolve.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
 class scout_checklistexecution_api_Failure(ConjureBeanType):
     """
     The time range where a check was failing.
@@ -21611,6 +23291,22 @@ scout_checklistexecution_api_Failure.__qualname__ = "Failure"
 scout_checklistexecution_api_Failure.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_Invalid(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_Invalid.__name__ = "Invalid"
+scout_checklistexecution_api_Invalid.__qualname__ = "Invalid"
+scout_checklistexecution_api_Invalid.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_InvalidStreamingComputeNode(ConjureEnumType):
 
     POINT_PERSISTENCE = 'POINT_PERSISTENCE'
@@ -21827,124 +23523,95 @@ class scout_checklistexecution_api_ListStreamingChecklistForAssetResponse(Conjur
         return self._next_page_token
 
 
-scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__name__ = "ListStreamingChecklistForAssetResponse"
-scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__qualname__ = "ListStreamingChecklistForAssetResponse"
-scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
-class scout_checklistexecution_api_ListStreamingChecklistRequest(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
-            'workspaces': ConjureFieldDefinition('workspaces', List[api_rids_WorkspaceRid]),
-            'page_token': ConjureFieldDefinition('pageToken', OptionalTypeWrapper[str])
-        }
-
-    __slots__: List[str] = ['_page_size', '_workspaces', '_page_token']
-
-    def __init__(self, workspaces: List[str], page_size: Optional[int] = None, page_token: Optional[str] = None) -> None:
-        self._page_size = page_size
-        self._workspaces = workspaces
-        self._page_token = page_token
-
-    @builtins.property
-    def page_size(self) -> Optional[int]:
-        """
-        Page sizes greater than 10_000 will be rejected. Default pageSize is 100.
-        """
-        return self._page_size
-
-    @builtins.property
-    def workspaces(self) -> List[str]:
-        return self._workspaces
-
-    @builtins.property
-    def page_token(self) -> Optional[str]:
-        return self._page_token
-
-
-scout_checklistexecution_api_ListStreamingChecklistRequest.__name__ = "ListStreamingChecklistRequest"
-scout_checklistexecution_api_ListStreamingChecklistRequest.__qualname__ = "ListStreamingChecklistRequest"
-scout_checklistexecution_api_ListStreamingChecklistRequest.__module__ = "nominal_api.scout_checklistexecution_api"
-
-
-class scout_checklistexecution_api_ListStreamingChecklistResponse(ConjureBeanType):
-
-    @builtins.classmethod
-    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
-        return {
-            'checklists': ConjureFieldDefinition('checklists', List[scout_rids_api_ChecklistRid]),
-            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[str])
-        }
-
-    __slots__: List[str] = ['_checklists', '_next_page_token']
-
-    def __init__(self, checklists: List[str], next_page_token: Optional[str] = None) -> None:
-        self._checklists = checklists
-        self._next_page_token = next_page_token
-
-    @builtins.property
-    def checklists(self) -> List[str]:
-        return self._checklists
-
-    @builtins.property
-    def next_page_token(self) -> Optional[str]:
-        return self._next_page_token
-
-
-scout_checklistexecution_api_ListStreamingChecklistResponse.__name__ = "ListStreamingChecklistResponse"
-scout_checklistexecution_api_ListStreamingChecklistResponse.__qualname__ = "ListStreamingChecklistResponse"
-scout_checklistexecution_api_ListStreamingChecklistResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__name__ = "ListStreamingChecklistForAssetResponse"
+scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__qualname__ = "ListStreamingChecklistForAssetResponse"
+scout_checklistexecution_api_ListStreamingChecklistForAssetResponse.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
-class scout_checklistexecution_api_NoPreviousFailure(ConjureBeanType):
-    """
-    No previous failure was computed for the check.
-    """
+class scout_checklistexecution_api_ListStreamingChecklistRequest(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
+            'page_size': ConjureFieldDefinition('pageSize', OptionalTypeWrapper[int]),
+            'workspaces': ConjureFieldDefinition('workspaces', List[api_rids_WorkspaceRid]),
+            'page_token': ConjureFieldDefinition('pageToken', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = []
+    __slots__: List[str] = ['_page_size', '_workspaces', '_page_token']
 
+    def __init__(self, workspaces: List[str], page_size: Optional[int] = None, page_token: Optional[str] = None) -> None:
+        self._page_size = page_size
+        self._workspaces = workspaces
+        self._page_token = page_token
 
+    @builtins.property
+    def page_size(self) -> Optional[int]:
+        """
+        Page sizes greater than 10_000 will be rejected. Default pageSize is 100.
+        """
+        return self._page_size
 
-scout_checklistexecution_api_NoPreviousFailure.__name__ = "NoPreviousFailure"
-scout_checklistexecution_api_NoPreviousFailure.__qualname__ = "NoPreviousFailure"
-scout_checklistexecution_api_NoPreviousFailure.__module__ = "nominal_api.scout_checklistexecution_api"
+    @builtins.property
+    def workspaces(self) -> List[str]:
+        return self._workspaces
 
+    @builtins.property
+    def page_token(self) -> Optional[str]:
+        return self._page_token
 
-class scout_checklistexecution_api_NotComputable(ConjureBeanType):
-    """
-    The result cannot be computed in a streaming context.
-    """
+
+scout_checklistexecution_api_ListStreamingChecklistRequest.__name__ = "ListStreamingChecklistRequest"
+scout_checklistexecution_api_ListStreamingChecklistRequest.__qualname__ = "ListStreamingChecklistRequest"
+scout_checklistexecution_api_ListStreamingChecklistRequest.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_ListStreamingChecklistResponse(ConjureBeanType):
 
     @builtins.classmethod
     def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
         return {
-            'message': ConjureFieldDefinition('message', str)
+            'checklists': ConjureFieldDefinition('checklists', List[scout_rids_api_ChecklistRid]),
+            'next_page_token': ConjureFieldDefinition('nextPageToken', OptionalTypeWrapper[str])
         }
 
-    __slots__: List[str] = ['_message']
+    __slots__: List[str] = ['_checklists', '_next_page_token']
 
-    def __init__(self, message: str) -> None:
-        self._message = message
+    def __init__(self, checklists: List[str], next_page_token: Optional[str] = None) -> None:
+        self._checklists = checklists
+        self._next_page_token = next_page_token
 
     @builtins.property
-    def message(self) -> str:
-        """
-        Why the result couldn't be computed
-        """
-        return self._message
+    def checklists(self) -> List[str]:
+        return self._checklists
+
+    @builtins.property
+    def next_page_token(self) -> Optional[str]:
+        return self._next_page_token
 
 
-scout_checklistexecution_api_NotComputable.__name__ = "NotComputable"
-scout_checklistexecution_api_NotComputable.__qualname__ = "NotComputable"
-scout_checklistexecution_api_NotComputable.__module__ = "nominal_api.scout_checklistexecution_api"
+scout_checklistexecution_api_ListStreamingChecklistResponse.__name__ = "ListStreamingChecklistResponse"
+scout_checklistexecution_api_ListStreamingChecklistResponse.__qualname__ = "ListStreamingChecklistResponse"
+scout_checklistexecution_api_ListStreamingChecklistResponse.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_NoPreviousFailure(ConjureBeanType):
+    """
+    No previous failure was computed for the check.
+    """
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_NoPreviousFailure.__name__ = "NoPreviousFailure"
+scout_checklistexecution_api_NoPreviousFailure.__qualname__ = "NoPreviousFailure"
+scout_checklistexecution_api_NoPreviousFailure.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
 class scout_checklistexecution_api_NotComputed(ConjureBeanType):
@@ -21986,7 +23653,6 @@ class scout_checklistexecution_api_ResolvedCheckStatus(ConjureBeanType):
     """
     Provides the resolution status for the required channels for a check and the set of invalid streaming compute nodes present within the check's compute graph.
 Uniqueness between checkRid and checkParameterIndex pairs is guaranteed.
-checkParameterIndex is optional and will be null if the check is not parameterized otherwise it will be the index of the parameter.
     """
 
     @builtins.classmethod
@@ -22012,6 +23678,10 @@ checkParameterIndex is optional and will be null if the check is not parameteriz
 
     @builtins.property
     def check_parameter_index(self) -> Optional[int]:
+        """
+        Checks can define a single range computation which can evaluate over multiple implementations of a context.
+The check implementation index will correspond to the implementation index of the check condition.
+        """
         return self._check_parameter_index
 
     @builtins.property
@@ -22028,6 +23698,22 @@ scout_checklistexecution_api_ResolvedCheckStatus.__qualname__ = "ResolvedCheckSt
 scout_checklistexecution_api_ResolvedCheckStatus.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_Skipped(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_Skipped.__name__ = "Skipped"
+scout_checklistexecution_api_Skipped.__qualname__ = "Skipped"
+scout_checklistexecution_api_Skipped.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -22057,6 +23743,22 @@ scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest.__qualname__
 scout_checklistexecution_api_StopStreamingChecklistForAssetsRequest.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_StreamingChecklistFailed(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_StreamingChecklistFailed.__name__ = "StreamingChecklistFailed"
+scout_checklistexecution_api_StreamingChecklistFailed.__qualname__ = "StreamingChecklistFailed"
+scout_checklistexecution_api_StreamingChecklistFailed.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_StreamingChecklistInfo(ConjureBeanType):
 
     @builtins.classmethod
@@ -22086,6 +23788,54 @@ scout_checklistexecution_api_StreamingChecklistInfo.__qualname__ = "StreamingChe
 scout_checklistexecution_api_StreamingChecklistInfo.__module__ = "nominal_api.scout_checklistexecution_api"
 
 
+class scout_checklistexecution_api_StreamingChecklistInitializing(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+        }
+
+    __slots__: List[str] = []
+
+
+
+scout_checklistexecution_api_StreamingChecklistInitializing.__name__ = "StreamingChecklistInitializing"
+scout_checklistexecution_api_StreamingChecklistInitializing.__qualname__ = "StreamingChecklistInitializing"
+scout_checklistexecution_api_StreamingChecklistInitializing.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
+class scout_checklistexecution_api_StreamingChecklistRunning(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'commit_id': ConjureFieldDefinition('commitId', scout_versioning_api_CommitId),
+            'check_results': ConjureFieldDefinition('checkResults', List[scout_checklistexecution_api_CheckLiveStatusResponse])
+        }
+
+    __slots__: List[str] = ['_commit_id', '_check_results']
+
+    def __init__(self, check_results: List["scout_checklistexecution_api_CheckLiveStatusResponse"], commit_id: str) -> None:
+        self._commit_id = commit_id
+        self._check_results = check_results
+
+    @builtins.property
+    def commit_id(self) -> str:
+        """
+        The commitId of the checklist that is currently executing.
+        """
+        return self._commit_id
+
+    @builtins.property
+    def check_results(self) -> List["scout_checklistexecution_api_CheckLiveStatusResponse"]:
+        return self._check_results
+
+
+scout_checklistexecution_api_StreamingChecklistRunning.__name__ = "StreamingChecklistRunning"
+scout_checklistexecution_api_StreamingChecklistRunning.__qualname__ = "StreamingChecklistRunning"
+scout_checklistexecution_api_StreamingChecklistRunning.__module__ = "nominal_api.scout_checklistexecution_api"
+
+
 class scout_checklistexecution_api_ValidateChecklistResolutionRequest(ConjureBeanType):
     """
     Validates that the channels referenced by the checklist can be resolved against the data sources.
@@ -67309,6 +69059,151 @@ secrets_api_UpdateSecretRequest.__qualname__ = "UpdateSecretRequest"
 secrets_api_UpdateSecretRequest.__module__ = "nominal_api.secrets_api"
 
 
+class security_api_workspace_Workspace(ConjureBeanType):
+
+    @builtins.classmethod
+    def _fields(cls) -> Dict[str, ConjureFieldDefinition]:
+        return {
+            'id': ConjureFieldDefinition('id', api_ids_WorkspaceId),
+            'rid': ConjureFieldDefinition('rid', api_rids_WorkspaceRid),
+            'org': ConjureFieldDefinition('org', authentication_api_OrgRid)
+        }
+
+    __slots__: List[str] = ['_id', '_rid', '_org']
+
+    def __init__(self, id: str, org: str, rid: str) -> None:
+        self._id = id
+        self._rid = rid
+        self._org = org
+
+    @builtins.property
+    def id(self) -> str:
+        """
+        A unique identifier for the workspace within the organization. The workspace ID must be lower case alphanumeric characters, optionally separated by hyphens.
+        """
+        return self._id
+
+    @builtins.property
+    def rid(self) -> str:
+        return self._rid
+
+    @builtins.property
+    def org(self) -> str:
+        return self._org
+
+
+security_api_workspace_Workspace.__name__ = "Workspace"
+security_api_workspace_Workspace.__qualname__ = "Workspace"
+security_api_workspace_Workspace.__module__ = "nominal_api.security_api_workspace"
+
+
+class security_api_workspace_WorkspaceService(Service):
+    """
+    This service provides information about workspaces. Workspaces provide access control boundaries. All resources in
+Nominal live within a workspace.
+    """
+
+    def get_workspaces(self, auth_header: str) -> List["security_api_workspace_Workspace"]:
+        """
+        Gets all workspaces that the requesting user belongs to.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/workspaces/v1/workspaces'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), List[security_api_workspace_Workspace], self._return_none_for_unknown_union_types)
+
+    def get_workspace(self, auth_header: str, workspace_rid: str) -> "security_api_workspace_Workspace":
+        """
+        Gets the workspace with the specified WorkspaceRid.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+            'workspaceRid': workspace_rid,
+        }
+
+        _json: Any = None
+
+        _path = '/workspaces/v1/workspaces/{workspaceRid}'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return _decoder.decode(_response.json(), security_api_workspace_Workspace, self._return_none_for_unknown_union_types)
+
+    def get_default_workspace(self, auth_header: str) -> Optional["security_api_workspace_Workspace"]:
+        """
+        Gets the default workspace for the requesting user. It may not be present if the user does not have
+access to any workspaces or no default workspace is configured for the user's organization.
+        """
+
+        _headers: Dict[str, Any] = {
+            'Accept': 'application/json',
+            'Authorization': auth_header,
+        }
+
+        _params: Dict[str, Any] = {
+        }
+
+        _path_params: Dict[str, Any] = {
+        }
+
+        _json: Any = None
+
+        _path = '/workspaces/v1/default-workspace'
+        _path = _path.format(**_path_params)
+
+        _response: Response = self._request(
+            'GET',
+            self._uri + _path,
+            params=_params,
+            headers=_headers,
+            json=_json)
+
+        _decoder = ConjureDecoder()
+        return None if _response.status_code == 204 else _decoder.decode(_response.json(), OptionalTypeWrapper[security_api_workspace_Workspace], self._return_none_for_unknown_union_types)
+
+
+security_api_workspace_WorkspaceService.__name__ = "WorkspaceService"
+security_api_workspace_WorkspaceService.__qualname__ = "WorkspaceService"
+security_api_workspace_WorkspaceService.__module__ = "nominal_api.security_api_workspace"
+
+
 class storage_datasource_api_CreateNominalDataSourceRequest(ConjureBeanType):
 
     @builtins.classmethod
@@ -73170,6 +75065,8 @@ scout_channelvariables_api_ChannelVariableName = str
 
 scout_datareview_api_ManualCheckEvaluationRid = str
 
+api_ids_WorkspaceId = str
+
 scout_asset_api_Channel = str
 
 scout_rids_api_FunctionRid = str
@@ -73244,6 +75141,8 @@ storage_writer_api_Field = str
 
 api_TagName = str
 
+authentication_api_UserRid = str
+
 scout_datasource_connection_api_ConnectionRid = str
 
 scout_channelvariables_api_ComputeSpecV1 = str
@@ -73346,6 +75245,8 @@ scout_api_HexColor = str
 
 scout_datasource_connection_api_SecretRid = str
 
+authorization_ApiKeyRid = str
+
 scout_rids_api_ApiKeyRid = str
 
 ingest_api_ChannelPrefix = OptionalTypeWrapper[str]