pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

pyegeria/egeria_tech_client.py

@@ -2,26 +2,51 @@
 SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
-Runtime manager is a view service that supports user interaction with the running platforms.
-
+The Tech Client is a facade that provides a unified interface to the most 
+commonly used technical OMVS modules.
 """
-from pyegeria.automated_curation_omvs import AutomatedCuration
-from pyegeria.classification_manager_omvs import ClassificationManager
-from pyegeria.data_designer import DataDesigner
-from pyegeria.egeria_cat_client import EgeriaCat
-from pyegeria.metadata_explorer_omvs import MetadataExplorer
-from pyegeria.registered_info import RegisteredInfo
-from pyegeria.runtime_manager_omvs import RuntimeManager
-from pyegeria.solution_architect_omvs import SolutionArchitect
-from pyegeria.template_manager_omvs import TemplateManager
-from pyegeria.valid_metadata_omvs import ValidMetadataManager
-from pyegeria.governance_officer import GovernanceOfficer
-from pyegeria.collection_manager import CollectionManager
-
+from pyegeria.omvs.action_author import ActionAuthor
+from pyegeria.omvs.actor_manager import ActorManager
+from pyegeria.omvs.asset_catalog import AssetCatalog
+from pyegeria.omvs.asset_maker import AssetMaker
+from pyegeria.omvs.automated_curation import AutomatedCuration
+from pyegeria.omvs.classification_manager import ClassificationManager
+from pyegeria.omvs.collection_manager import CollectionManager
+from pyegeria.omvs.community_matters_omvs import CommunityMatters
+from pyegeria.omvs.data_designer import DataDesigner
+from pyegeria.omvs.data_discovery import DataDiscovery
+from pyegeria.omvs.data_engineer import DataEngineer
+from pyegeria.omvs.digital_business import DigitalBusiness
+from pyegeria.omvs.external_links import ExternalReferences
+from pyegeria.omvs.feedback_manager import FeedbackManager
+from pyegeria.omvs.glossary_manager import GlossaryManager
+from pyegeria.omvs.governance_officer import GovernanceOfficer
+from pyegeria.omvs.lineage_linker import LineageLinker
+from pyegeria.omvs.location_arena import Location
+from pyegeria.omvs.metadata_expert import MetadataExpert
+from pyegeria.omvs.metadata_explorer_omvs import MetadataExplorer
+from pyegeria.omvs.my_profile import MyProfile
+from pyegeria.omvs.notification_manager import NotificationManager
+from pyegeria.omvs.people_organizer import PeopleOrganizer
+from pyegeria.omvs.product_manager import ProductManager
+from pyegeria.omvs.project_manager import ProjectManager
+from pyegeria.omvs.reference_data import ReferenceDataManager
+from pyegeria.omvs.registered_info import RegisteredInfo
+from pyegeria.omvs.runtime_manager import RuntimeManager
+from pyegeria.omvs.schema_maker import SchemaMaker
+from pyegeria.omvs.solution_architect import SolutionArchitect
+from pyegeria.omvs.specification_properties import SpecificationProperties
+from pyegeria.omvs.subject_area import SubjectArea
+from pyegeria.omvs.template_manager_omvs import TemplateManager
+from pyegeria.omvs.time_keeper import TimeKeeper
+from pyegeria.omvs.valid_metadata import ValidMetadataManager
+from pyegeria.omvs.valid_metadata_lists import ValidMetadataLists
+from pyegeria.omvs.valid_type_lists import ValidTypeLists
+from pyegeria.core._globals import NO_ELEMENTS_FOUND
 
 class EgeriaTech:
     """
-    Client for technical Egeria users using composition.
+    Client for technical Egeria users using lazy-loading composition.
 
     Attributes:
         view_server: str
@@ -51,65 +76,127 @@ class EgeriaTech:
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
+        self.token = token
 
-        # Compose sub-clients
-        self._auto_curate = AutomatedCuration(view_server, platform_url, user_id, user_pwd, token)
-        self._cat = EgeriaCat(view_server, platform_url, user_id, user_pwd, token)
-        self._class_mgr = ClassificationManager(view_server, platform_url, user_id, user_pwd, token)
-        self._reg_info = RegisteredInfo(view_server, platform_url, user_id, user_pwd, token)
-        self._runtime = RuntimeManager(view_server, platform_url, user_id, user_pwd, token)
-        self._valid = ValidMetadataManager(view_server, platform_url, user_id, user_pwd, token)
-        self._explorer = MetadataExplorer(view_server, platform_url, user_id, user_pwd, token)
-        self._sol_arch = SolutionArchitect(view_server, platform_url, user_id, user_pwd, token)
-        self._designer = DataDesigner(view_server, platform_url, user_id, user_pwd, token)
-        self._templates = TemplateManager(view_server, platform_url, user_id, user_pwd, token)
-        self._gov_officer = GovernanceOfficer(view_server, platform_url, user_id, user_pwd, token)
-        self._collections = CollectionManager(view_server, platform_url, user_id, user_pwd, token)
-
-        self._subclients = [
-            self._auto_curate,
-            self._cat,
-            self._class_mgr,
-            self._reg_info,
-            self._runtime,
-            self._valid,
-            self._explorer,
-            self._sol_arch,
-            self._designer,
-            self._templates,
-            self._gov_officer,
-            self._collections,
-        ]
+        # Mapping of attribute names to their classes for lazy loading
+        self._subclient_map = {
+            "auto_curate": AutomatedCuration,
+            "class_mgr": ClassificationManager,
+            "reg_info": RegisteredInfo,
+            "runtime": RuntimeManager,
+            "valid": ValidMetadataManager,
+            "explorer": MetadataExplorer,
+            "expert": MetadataExpert,
+            "sol_arch": SolutionArchitect,
+            "designer": DataDesigner,
+            "data_designer": DataDesigner,
+            "glossary": GlossaryManager,
+            "templates": TemplateManager,
+            "template_manager": TemplateManager,
+            "gov_officer": GovernanceOfficer,
+            "collections": CollectionManager,
+            "external_references": ExternalReferences,
+            "actor_manager": ActorManager,
+            "time_keeper": TimeKeeper,
+            "product_manager": ProductManager,
+            "location_arena": Location,
+            "data_discovery": DataDiscovery,
+            "data_engineer": DataEngineer,
+            "digital_business": DigitalBusiness,
+            "lineage_linker": LineageLinker,
+            "schema_maker": SchemaMaker,
+            "valid_types": ValidTypeLists,
+            "valid_type_lists": ValidTypeLists,
+            "valid_metadata_lists": ValidMetadataLists,
+            "action_author": ActionAuthor,
+            "asset_catalog": AssetCatalog,
+            "asset_maker": AssetMaker,
+            "community": CommunityMatters,
+            "community_matters": CommunityMatters,
+            "feedback": FeedbackManager,
+            "feedback_manager": FeedbackManager,
+            "my_profile": MyProfile,
+            "notifications": NotificationManager,
+            "notification_manager": NotificationManager,
+            "people_organizer": PeopleOrganizer,
+            "projects": ProjectManager,
+            "project_manager": ProjectManager,
+            "reference_data": ReferenceDataManager,
+            "specification_properties": SpecificationProperties,
+            "subject_area": SubjectArea,
+            "valid": ValidMetadataManager,
+            "valid_metadata": ValidMetadataManager,
+        }
+        self._instantiated_clients = {}
+        self.NO_ELEMENTS_FOUND = NO_ELEMENTS_FOUND
+
+    def _get_subclient(self, attr_name: str):
+        """Lazy-load and cache sub-clients."""
+        if attr_name not in self._instantiated_clients:
+            client_cls = self._subclient_map[attr_name]
+            self._instantiated_clients[attr_name] = client_cls(
+                self.view_server,
+                self.platform_url,
+                self.user_id,
+                self.user_pwd,
+                self.token,
+            )
+        return self._instantiated_clients[attr_name]
 
     def __getattr__(self, name):
-        for sub in self._subclients:
-            if hasattr(sub, name):
-                return getattr(sub, name)
-        raise AttributeError(f"{self.__class__.__name__!s} object has no attribute {name!r}")
+        """Delegate method calls to sub-clients, instantiating them on-demand."""
+        # Allow direct access to sub-clients if the name matches a key in the map
+        if name in self._subclient_map:
+            return self._get_subclient(name)
+
+        # Check already instantiated clients first for speed
+        for inst in self._instantiated_clients.values():
+            if hasattr(inst, name):
+                return getattr(inst, name)
+
+        # Look through the map for a class that provides this method
+        for attr_name, client_cls in self._subclient_map.items():
+            if hasattr(client_cls, name):
+                client = self._get_subclient(attr_name)
+                return getattr(client, name)
+
+        raise AttributeError(
+            f"{self.__class__.__name__!s} object has no attribute {name!r}"
+        )
 
     def create_egeria_bearer_token(self, user_id: str = None, user_pwd: str = None):
-        token_val = None
-        for sub in self._subclients:
-            token_val = sub.create_egeria_bearer_token(user_id, user_pwd)
+        """Create token and synchronize it across all instantiated sub-clients."""
+        # Use a reliable sub-client to generate the token (e.g., collections)
+        helper = self._get_subclient("collections")
+        token_val = helper.create_egeria_bearer_token(user_id, user_pwd)
+        self.set_bearer_token(token_val)
         return token_val
 
     def set_bearer_token(self, token: str) -> None:
-        for sub in self._subclients:
+        """Update token for the tech client and all active sub-clients."""
+        self.token = token
+        for sub in self._instantiated_clients.values():
             sub.set_bearer_token(token)
 
     def get_token(self) -> str:
-        for sub in self._subclients:
+        """Retrieve the current token from state or an active sub-client."""
+        if self.token:
+            return self.token
+        for sub in self._instantiated_clients.values():
             if hasattr(sub, "get_token"):
                 return sub.get_token()
         return None
 
     def close_session(self) -> None:
-        for sub in self._subclients:
+        """Close sessions for all sub-clients that were instantiated."""
+        for sub in self._instantiated_clients.values():
             if hasattr(sub, "close_session"):
                 try:
                     sub.close_session()
                 except Exception:
                     pass
+        self._instantiated_clients.clear()
+
 
 if __name__ == "__main__":
     print("Main-Tech Client")

pyegeria/models/__init__.py

@@ -0,0 +1,150 @@
+# Model Imports
+from pyegeria.models.models import (
+    MembershipStatus,
+    ValidStatusValues,
+    SequencingOrder,
+    DeleteMethod,
+    to_camel_case,
+    PyegeriaModel,
+    OpenMetadataRootProperties,
+    RelationshipBeanProperties,
+    ClassificationBeanProperties,
+    ReferenceableProperties,
+    RequestBody,
+    NewRelationshipRequestBody,
+    NewAttachmentRequestBody,
+    DeleteRequestBody,
+    DeleteElementRequestBody,
+    DeleteRelationshipRequestBody,
+    DeleteClassificationRequestBody,
+    InitialClassifications,
+    NewElementRequestBody,
+    NewClassificationRequestBody,
+    UpdateClassificationRequestBody,
+    UpdateRelationshipRequestBody,
+    TemplateRequestBody,
+    UpdateElementRequestBody,
+    UpdatePropertiesRequestBody,
+    MetadataSourceRequestBody,
+    UpdateEffectivityDatesRequestBody,
+    OpenMetadataDeleteRequestBody,
+    ArchiveRequestBody,
+    NewOpenMetadataElementRequestBody,
+    NewRelatedElementsRequestBody,
+    GetRequestBody,
+    ResultsRequestBody,
+    LevelIdentifierQueryBody,
+    FilterRequestBody,
+    SearchStringRequestBody,
+    FindRequestBody,
+    FindPropertyNamesRequestBody,
+    DeploymentStatusSearchString,
+    DeploymentStatusFilterRequestBody,
+    ContentStatusSearchString,
+    ContentStatusFilterRequestBody,
+    ActivityStatusSearchString,
+    ActivityStatusFilterRequestBody,
+    ActivityStatusRequestBody,
+    ActionRequestBody,
+    get_defined_fields,
+    get_defined_field_values,
+    TypeInfo,
+    OriginInfo,
+    VersionInfo,
+    AnchorClassificationProperties,
+    SubjectAreaClassificationProperties,
+    CanonicalVocabularyClassificationProperties,
+    ElementClassification,
+    CollectionProperties,
+    GlossaryProperties,
+    ElementHeader,
+    RelatedElement,
+    AssociatedGlossaryItem,
+    OpenMetadataRootElement,
+)
+from pyegeria.core._exceptions import (
+    PyegeriaException,
+    PyegeriaConnectionException,
+    PyegeriaInvalidParameterException,
+    PyegeriaClientException,
+    PyegeriaAPIException,
+    PyegeriaUnauthorizedException,
+    PyegeriaNotFoundException,
+    PyegeriaUnknownException,
+)
+
+__all__ = [
+    # Enums
+    "MembershipStatus",
+    "ValidStatusValues",
+    "SequencingOrder",
+    "DeleteMethod",
+    # Utilities
+    "to_camel_case",
+    "get_defined_fields",
+    "get_defined_field_values",
+    # Models
+    "PyegeriaModel",
+    "OpenMetadataRootProperties",
+    "RelationshipBeanProperties",
+    "ClassificationBeanProperties",
+    "ReferenceableProperties",
+    "RequestBody",
+    "NewRelationshipRequestBody",
+    "NewAttachmentRequestBody",
+    "DeleteRequestBody",
+    "DeleteElementRequestBody",
+    "DeleteRelationshipRequestBody",
+    "DeleteClassificationRequestBody",
+    "InitialClassifications",
+    "NewElementRequestBody",
+    "NewClassificationRequestBody",
+    "UpdateClassificationRequestBody",
+    "UpdateRelationshipRequestBody",
+    "TemplateRequestBody",
+    "UpdateElementRequestBody",
+    "UpdatePropertiesRequestBody",
+    "MetadataSourceRequestBody",
+    "UpdateEffectivityDatesRequestBody",
+    "OpenMetadataDeleteRequestBody",
+    "ArchiveRequestBody",
+    "NewOpenMetadataElementRequestBody",
+    "NewRelatedElementsRequestBody",
+    "GetRequestBody",
+    "ResultsRequestBody",
+    "LevelIdentifierQueryBody",
+    "FilterRequestBody",
+    "SearchStringRequestBody",
+    "FindRequestBody",
+    "FindPropertyNamesRequestBody",
+    "DeploymentStatusSearchString",
+    "DeploymentStatusFilterRequestBody",
+    "ContentStatusSearchString",
+    "ContentStatusFilterRequestBody",
+    "ActivityStatusSearchString",
+    "ActivityStatusFilterRequestBody",
+    "ActivityStatusRequestBody",
+    "ActionRequestBody",
+    "TypeInfo",
+    "OriginInfo",
+    "VersionInfo",
+    "AnchorClassificationProperties",
+    "SubjectAreaClassificationProperties",
+    "CanonicalVocabularyClassificationProperties",
+    "ElementClassification",
+    "CollectionProperties",
+    "GlossaryProperties",
+    "ElementHeader",
+    "RelatedElement",
+    "AssociatedGlossaryItem",
+    "OpenMetadataRootElement",
+    # Exceptions
+    "PyegeriaException",
+    "PyegeriaConnectionException",
+    "PyegeriaInvalidParameterException",
+    "PyegeriaClientException",
+    "PyegeriaAPIException",
+    "PyegeriaUnauthorizedException",
+    "PyegeriaNotFoundException",
+    "PyegeriaUnknownException",
+]

pyegeria/{models.py → models/models.py}

@@ -242,7 +242,8 @@ class NewRelationshipRequestBody(RequestBody):
     class_: Annotated[Literal["NewRelationshipRequestBody"], Field(alias="class")]
     make_anchor: bool | None = False
     anchor_scope_guid: str | None = None
-    properties: dict | RelationshipBeanProperties | None = None
+    properties: dict | None = None
+    relationship_properties: dict | None = Field(default=None, alias="relationshipProperties")
 
 
 class DeleteRequestBody(RequestBody):
@@ -253,6 +254,17 @@ class DeleteRequestBody(RequestBody):
     archive_process: str | None = None
     archive_properties: dict | None = None
 
+class DeleteElementRequestBody(RequestBody):
+    class_: Annotated[Literal["DeleteElementRequestBody"], Field(alias="class")]
+
+
+class DeleteRelationshipRequestBody(RequestBody):
+    class_: Annotated[Literal["DeleteRelationshipRequestBody"], Field(alias="class")]
+
+
+class DeleteClassificationRequestBody(RequestBody):
+    class_: Annotated[Literal["DeleteClassificationRequestBody"], Field(alias="class")]
+
 
 class InitialClassifications(PyegeriaModel):
     class_: str = Field(alias="class"),
@@ -271,17 +283,31 @@ class InitialClassifications(PyegeriaModel):
             }
 
 
+class NewAttachmentRequestBody(RequestBody):
+    class_: Annotated[Literal["NewAttachmentRequestBody"], Field(alias="class")]
+    initial_classifications:  Dict[str, InitialClassifications] | None = None
+    parent_relationship_properties: dict | None = None
+    properties: dict | None = None
+    external_source_guid: str | None = None
+    external_source_name: str | None = None
+    effective_time: datetime | None = None
+    for_lineage: bool | None = False
+    for_duplicate_processing: bool | None = False
+
+
 class NewElementRequestBody(RequestBody):
     class_: Annotated[Literal["NewElementRequestBody"], Field(alias="class")]
     anchor_guid: str | None = None
     is_own_anchor: bool | None = True
     anchor_scope_guid: str | None = None
     initial_classifications:  Dict[str, InitialClassifications] | None = None
-    initial_status: ValidStatusValues | str= ValidStatusValues.ACTIVE
+    # initial_status: ValidStatusValues | str= ValidStatusValues.ACTIVE
+    parent_relationship_properties: dict | None = None
+    properties: dict | None = None
     parent_guid: str | None = None
     parent_relationship_type_name: str | None = None
     parent_at_end_1: bool | None = True
-    properties: dict | None = None
+    properties: dict | None =None
 
 
 class NewClassificationRequestBody(RequestBody):
@@ -312,7 +338,7 @@ class TemplateRequestBody(PyegeriaModel):
     parent_at_end_1: bool | None = True
     template_guid: str
     replacement_properties: dict[str, Any] = {}
-    placeholder_properties: dict[str, Any] = {}
+    placeholder_property_values: dict[str, Any] = {}
     deep_copy: bool | None = False
     effective_from: datetime | None = None
     effective_to: datetime | None = None
@@ -324,21 +350,64 @@ class UpdateElementRequestBody(PyegeriaModel):
     class_: Annotated[Literal["UpdateElementRequestBody"], Field(alias="class")]
     properties: dict[str, Any] = {}
     merge_update: bool | None = True
-    external_source_guid: str | None = None
-    external_source_name: str | None = None
-    effective_time: datetime | None = None
-    for_lineage: bool | None = False
-    for_duplicate_processing: bool | None = False
 
 
-class UpdateStatusRequestBody(PyegeriaModel):
-    class_: Annotated[Literal["UpdateStatusRequestBody"], Field(alias="class")]
-    new_status: str
-    external_source_guid: str | None = None
-    external_source_name: str | None = None
-    effective_time: datetime | None = None
-    for_lineage: bool | None = False
-    for_duplicate_processing: bool | None = False
+class UpdatePropertiesRequestBody(RequestBody):
+    class_: Annotated[Literal["UpdatePropertiesRequestBody"], Field(alias="class")]
+    properties: dict | None = None
+    replace_properties: bool | None = False
+
+
+class MetadataSourceRequestBody(RequestBody):
+    class_: Annotated[Literal["MetadataSourceRequestBody"], Field(alias="class")]
+
+
+class UpdateEffectivityDatesRequestBody(RequestBody):
+    class_: Annotated[Literal["UpdateEffectivityDatesRequestBody"], Field(alias="class")]
+    effective_from: datetime | None = None
+    effective_to: datetime | None = None
+
+
+class OpenMetadataDeleteRequestBody(RequestBody):
+    class_: Annotated[Literal["OpenMetadataDeleteRequestBody"], Field(alias="class")]
+
+
+class ArchiveRequestBody(RequestBody):
+    class_: Annotated[Literal["ArchiveRequestBody"], Field(alias="class")]
+    archive_properties: dict | None = None
+
+
+class NewOpenMetadataElementRequestBody(RequestBody):
+    class_: Annotated[Literal["NewOpenMetadataElementRequestBody"], Field(alias="class")]
+    type_name: str | None = None
+    initial_classifications: Dict[str, InitialClassifications] | None = None
+    anchor_guid: str | None = None
+    is_own_anchor: bool | None = False
+    effective_from: datetime | None = None
+    effective_to: datetime | None = None
+    properties: dict | None = None
+    parent_guid: str | None = None
+    parent_relationship_type_name: str | None = None
+    parent_relationship_properties: dict | None = None
+    parent_at_end_1: bool | None = True
+
+
+class NewRelatedElementsRequestBody(RequestBody):
+    class_: Annotated[Literal["NewRelatedElementsRequestBody"], Field(alias="class")]
+    relationship_type_name: str | None = None
+    end_1_guid: str | None = None
+    end_2_guid: str | None = None
+    properties: dict | None = None
+
+
+# class UpdateStatusRequestBody(PyegeriaModel):
+#     class_: Annotated[Literal["UpdateStatusRequestBody"], Field(alias="class")]
+#     new_status: str
+#     external_source_guid: str | None = None
+#     external_source_name: str | None = None
+#     effective_time: datetime | None = None
+#     for_lineage: bool | None = False
+#     for_duplicate_processing: bool | None = False
 
 
 class GetRequestBody(PyegeriaModel):
@@ -355,21 +424,27 @@ class GetRequestBody(PyegeriaModel):
     effective_time: datetime | None = None
     for_lineage: bool | None = False
     for_duplicate_processing: bool | None = False
-    relationship_page_size: int | None = None
+    relationship_page_size: int = 0
 
 
 class ResultsRequestBody(GetRequestBody):
     class_: Annotated[Literal["ResultsRequestBody"], Field(alias="class")]
-    limit_results_by_status: list[ValidStatusValues] | None= None
+    limit_results_by_status: list[ValidStatusValues] | None= None # header status
+    relationships_page_size: int = 0
     anchor_guid: str | None = None
     sequencing_order: SequencingOrder | None = None
     sequencing_property: str | None = None
     start_from: int = 0
     page_size: int = 0
 
+class LevelIdentifierQueryBody(ResultsRequestBody):
+    class_: Annotated[Literal["LevelIdentifierQueryProperties"], Field(alias="class")]
+    return_specific_level: bool = True
+    level_identifier: int
+
 class FilterRequestBody(ResultsRequestBody):
     class_: Annotated[Literal["FilterRequestBody"], Field(alias="class")]
-    filter: str
+    filter_string: Annotated[str, Field(alias="filter")]
 
 
 class SearchStringRequestBody(ResultsRequestBody):
@@ -380,6 +455,67 @@ class SearchStringRequestBody(ResultsRequestBody):
     ignore_case: bool = False
 
 
+class FindRequestBody(ResultsRequestBody):
+    class_: Annotated[Literal["FindRequestBody"], Field(alias="class")]
+    metadata_element_type_name: str | None = Field(None, alias="metadataElementTypeName")
+    metadata_element_subtype_names: list[str] | None = Field(
+        None, alias="metadataElementSubtypeNames"
+    )
+    search_properties: dict | None = Field(None, alias="searchProperties")
+    match_classifications: dict | None = Field(None, alias="matchClassifications")
+    as_of_time: datetime | None = Field(None, alias="asOfTime")
+    effective_time: datetime | None = Field(None, alias="effectiveTime")
+
+
+class FindPropertyNamesRequestBody(ResultsRequestBody):
+    class_: Annotated[Literal["FindPropertyNamesProperties"], Field(alias="class")]
+    property_value: str | None = None
+    property_names: list[str] | None = None
+
+
+class DeploymentStatusSearchString(SearchStringRequestBody):
+    class_: Annotated[Literal["DeploymentStatusSearchString"], Field(alias="class")]
+    deployment_status: Optional[str] = Field(None, alias="deploymentStatus")
+
+
+class DeploymentStatusFilterRequestBody(FilterRequestBody):
+    class_: Annotated[Literal["DeploymentStatusFilterRequestBody"], Field(alias="class")]
+    deployment_status: Optional[str] = Field(None, alias="deploymentStatus")
+
+
+class ContentStatusSearchString(SearchStringRequestBody):
+    class_: Annotated[Literal["ContentStatusSearchString"], Field(alias="class")]
+    content_status: Optional[str] = Field(None, alias="contentStatus")
+
+
+class ContentStatusFilterRequestBody(FilterRequestBody):
+    class_: Annotated[Literal["ContentStatusFilterRequestBody"], Field(alias="class")]
+    content_status: Optional[str] = Field(None, alias="contentStatus")
+
+
+class ActivityStatusSearchString(SearchStringRequestBody):
+    class_: Annotated[Literal["ActivityStatusSearchString"], Field(alias="class")]
+    activity_status: Optional[str] = Field(None, alias="activityStatus")
+
+
+class ActivityStatusFilterRequestBody(FilterRequestBody):
+    class_: Annotated[Literal["ActivityStatusFilterRequestBody"], Field(alias="class")]
+    activity_status: Optional[str] = Field(None, alias="activityStatus")
+
+
+class ActivityStatusRequestBody(ResultsRequestBody):
+    class_: Annotated[Literal["ActivityStatusRequestBody"], Field(alias="class")]
+    activity_status: Optional[str] = Field(None, alias="activityStatus")
+
+
+class ActionRequestBody(RequestBody):
+    class_: Annotated[Literal["ActionRequestBody"], Field(alias="class")]
+    properties: Optional[dict] = None
+    action_sponsor_guid: Optional[str] = Field(None, alias="actionSponsorGUID")
+    action_executor_guid: Optional[str] = Field(None, alias="actionExecutorGUID")
+    action_target_guids: Optional[list[str]] = Field(None, alias="actionTargetGUIDs")
+
+
 
 #######
 # This gets only the fields in the most specific model