pyegeria 5.4.0.18__py3-none-any.whl → 5.4.0.19__py3-none-any.whl

pyegeria/collection_manager_omvs.py

@@ -425,9 +425,9 @@ class CollectionManager(Client2):
           The principle specified by the user_id does not have authorization for the requested action
 
         """
-
+        search_string = search_string if search_string != "*" else None
         body = {
-            "class": "FilterRequestBody", "filter": search_string
+            "class": "SearchStringRequestBody", "searchString": search_string
             }
 
         resp = await self._async_find_collections_w_body(body, classification_name, starts_with, ends_with, ignore_case,
@@ -615,11 +615,11 @@ class CollectionManager(Client2):
         Parameters
         ----------
         collection_type: str
-            collection_type to use to find matching collections.
+            category to use to find matching collections.
         classification_name: str, optional
             An optional filter on the search,  e.g., DataSpec
         body: dict, optional, default = None
-            Provides, a full request body. If specified, the body filter parameter supercedes the collection_type
+            Provides, a full request body. If specified, the body filter parameter supercedes the category
             parameter.
         start_from: int, [default=0], optional
                     When multiple pages of results are available, the page number to start from.
@@ -701,11 +701,11 @@ class CollectionManager(Client2):
         Parameters
         ----------
         collection_type: str
-            collection_type to use to find matching collections.
+            category to use to find matching collections.
         classification_name: str, optional
             An optional filter on the search, e.g., DataSpec
         body: dict, optional, default = None
-            Provides, a full request body. If specified, the body filter parameter supersedes the collection_type
+            Provides, a full request body. If specified, the body filter parameter supersedes the category
             parameter.
         start_from: int, [default=0], optional
                     When multiple pages of results are available, the page number to start from.

pyegeria/collection_models.py

@@ -0,0 +1,168 @@
+"""
+Pydantic models representing collection-related JSON structures from Egeria.
+
+These models represent a subset of the JSON payload structure found in the Egeria API responses,
+focusing on collections and their related components.
+"""
+
+from datetime import datetime
+from typing import List, Dict, Optional, Any, Literal
+
+from pydantic import BaseModel, Field
+
+from pyegeria.models import PyegeriaModel
+
+
+# --- Basic Type Models ---
+
+class TypeInfo(PyegeriaModel):
+    """Represents type information for an element."""
+    type_id: str
+    type_name: str
+    super_type_names: Optional[List[str]] = None
+    type_version: int
+    type_description: str
+    type_category: str
+
+
+class OriginInfo(PyegeriaModel):
+    """Represents origin information for an element."""
+    source_server: str
+    origin_category: str
+    home_metadata_collection_id: str
+    home_metadata_collection_name: str
+    license: Optional[str] = None
+
+
+class VersionInfo(PyegeriaModel):
+    """Represents version information for an element."""
+    created_by: str
+    updated_by: str
+    create_time: datetime
+    update_time: datetime
+    version: int
+
+
+# --- Classification Models ---
+
+class ClassificationProperties(PyegeriaModel):
+    """Base model for classification properties."""
+    pass
+
+
+class AnchorClassificationProperties(ClassificationProperties):
+    """Properties for Anchors classification."""
+    anchor_type_name: str
+    anchor_domain_name: str
+    anchor_guid: Optional[str] = None
+    anchor_scope_guid: Optional[str] = None
+
+
+class SubjectAreaClassificationProperties(ClassificationProperties):
+    """Properties for SubjectArea classification."""
+    display_name: Optional[str] = None
+    subject_area_name: Optional[str] = None
+
+
+class CanonicalVocabularyClassificationProperties(ClassificationProperties):
+    """Properties for CanonicalVocabulary classification."""
+    scope: str
+
+
+class ConnectorTypeDirectoryClassificationProperties(ClassificationProperties):
+    """Properties for ConnectorTypeDirectory classification."""
+    pass
+
+
+class ElementClassification(PyegeriaModel):
+    """Represents a classification applied to an element."""
+    class_: str = Field(alias="class")
+    header_version: int
+    status: str
+    type_: TypeInfo = Field(alias="type")
+    origin: OriginInfo
+    versions: VersionInfo
+    classification_origin: str
+    classification_name: str
+    classification_properties: Optional[Dict[str, Any]] = None
+
+
+# --- Properties Models ---
+
+class CollectionProperties(PyegeriaModel):
+    """Represents the properties of a Collection."""
+    class_: str = Field(alias="class")
+    type_name: str
+    extended_properties: Optional[Dict[str, Any]] = {}
+    qualified_name: str
+    display_name: str
+    description: Optional[str] = None
+
+
+class GlossaryProperties(PyegeriaModel):
+    """Represents the properties of a Glossary."""
+    display_name: str
+    qualified_name: str
+    usage: Optional[List[str]] = None
+    description: Optional[List[str]] = None
+    language: Optional[List[str]] = None
+
+
+# --- Header Models ---
+
+class ElementHeader(PyegeriaModel):
+    """Represents the header information for an element."""
+    class_: str = Field(alias="class")
+    header_version: int
+    status: str
+    type_: TypeInfo = Field(alias="type")
+    origin: OriginInfo
+    versions: VersionInfo
+    guid: str
+    anchor: Optional[ElementClassification] = None
+    subject_area: Optional[ElementClassification] = Field(None, alias="subjectArea")
+    other_classifications: Optional[List[ElementClassification]] = Field([], alias="otherClassifications")
+    collection_categories: Optional[List[ElementClassification]] = Field(None, alias="collectionCategories")
+
+
+# --- Relationship Models ---
+
+class RelationshipHeader(ElementHeader):
+    """Represents the header information for a relationship."""
+    pass
+
+
+class RelatedElement(PyegeriaModel):
+    """Represents a related element in a relationship."""
+    element_header: ElementHeader = Field(alias="elementHeader")
+    properties: GlossaryProperties
+
+
+class AssociatedGlossaryItem(PyegeriaModel):
+    """Represents an associated glossary item."""
+    relationship_header: RelationshipHeader = Field(alias="relationshipHeader")
+    related_element: RelatedElement = Field(alias="relatedElement")
+    related_element_at_end1: Optional[bool] = Field(None, alias="relatedElementAtEnd1")
+
+
+class CollectionMember(PyegeriaModel):
+    """Represents a member of a collection."""
+    relationship_header: RelationshipHeader = Field(alias="relationshipHeader")
+    related_element: RelatedElement = Field(alias="relatedElement")
+    related_element_at_end1: Optional[bool] = Field(None, alias="relatedElementAtEnd1")
+
+
+# --- Root Models ---
+
+class OpenMetadataRootElement(PyegeriaModel):
+    """Represents the root element in the JSON payload."""
+    class_: str = Field(alias="class")
+    element_header: ElementHeader = Field(alias="elementHeader")
+    associated_glossaries: Optional[List[AssociatedGlossaryItem]] = Field(None, alias="associatedGlossaries")
+    collection_members: Optional[List[CollectionMember]] = Field(None, alias="collectionMembers")
+    mermaid_graph: Optional[str] = Field(None, alias="mermaidGraph")
+    properties: CollectionProperties
+
+
+# --- Overall Payload Type ---
+CollectionPayload = List[OpenMetadataRootElement]

pyegeria/load_config.py

@@ -52,8 +52,8 @@ class PyegeriaSettings(BaseSettings):
     # Additional settings that can be loaded from .env
     pyegeria_console_width: int = 200
     pyegeria_user_format_sets_dir: str = "~/.pyegeria/format_sets"
-    egeria_user_name: str = "erinoverview"
-    egeria_user_password: str = "secret"
+    egeria_user_name: str = ""
+    egeria_user_password: str = ""
     
     model_config = SettingsConfigDict(
         env_file=".env",
@@ -148,8 +148,8 @@ class UserProfileConfig(BaseModel):
     egeria_home_collection: str = Field(default="MyHome", alias="Egeria Home Collection")
     egeria_home_glossary_name: str = Field(default="Egeria-Markdown", alias="Egeria Home Glossary Name")
     egeria_local_qualifier: str = Field(default="PDR", alias="Egeria Local Qualifier")
-    user_name: str = "erinoverview"
-    user_pwd: str = "secret"
+    user_name: Optional[str] = "erinoverview"
+    user_pwd: Optional[str] = "secret"
     
     @validator('user_name')
     def validate_user_name(cls, v):

pyegeria/models.py

@@ -0,0 +1,468 @@
+"""
+
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Pydantic Models representing common request and response bodies.
+
+"""
+from datetime import datetime
+from enum import Enum, StrEnum
+from typing import Literal, Annotated, Any, Optional, Dict
+
+from pydantic import BaseModel, Field, ConfigDict, root_validator, model_validator
+
+
+class MembershipStatus(StrEnum):
+    """
+    Represents the various statuses of membership in a system.
+
+    This class is an enumeration that defines possible states related to the
+    membership lifecycle. These statuses are typically used to denote the
+    state of an item, resource, or entity within a system, and they assist
+    in workflow management or status tracking.
+
+    Attributes:
+        UNKNOWN (MembershipStatus): Status indicating that the current
+            state is not known.
+        DISCOVERED (MembershipStatus): Status indicating that the entity
+            has been identified or uncovered in some way.
+        PROPOSED (MembershipStatus): Status indicating that the entity
+            has been suggested or submitted for consideration.
+        IMPORTED (MembershipStatus): Status indicating that the entity
+            has been brought into a system or context from an external
+            source.
+        VALIDATED (MembershipStatus): Status indicating that the entity
+            has been verified or approved.
+        DEPRECATED (MembershipStatus): Status indicating that the entity
+            is no longer recommended for use and may be phased out.
+        OBSOLETE (MembershipStatus): Status indicating that the entity
+            is no longer in use and is considered outdated.
+        OTHER (MembershipStatus): Status indicating an additional,
+            unspecified, or alternate state not covered by the predefined
+            statuses.
+    """
+    UNKNOWN = "UNKNOWN"
+    DISCOVERED = "DISCOVERED"
+    PROPOSED = "PROPOSED"
+    IMPORTED = "IMPORTED"
+    VALIDATED = "VALIDATED"
+    DEPRECATED = "DEPRECATED"
+    OBSOLETE = "OBSOLETE"
+    OTHER = "OTHER"
+
+
+class ValidStatusValues(StrEnum):
+    """
+    Defines a set of valid status values to represent various states or life-cycle stages.
+
+    This enumeration is designed to provide a standardized set of named constants for indicating
+    statuses related to developmental, operational, or administrative processes. It can be used
+    across different domains where such statuses are required. Each value corresponds to a specific
+    state and is represented by a meaningful string.
+
+    Attributes:
+        UNKNOWN: Represents an unknown state where the specific status is not defined.
+        DRAFT: Indicates that the item or process is in draft mode and not finalized.
+        PREPARED: Denotes readiness but not yet officially deployed or used.
+        PROPOSED: Represents a state where an idea or plan has been proposed but not yet approved.
+        APPROVED: Indicates official approval has been granted for the item or process.
+        REJECTED: Refers to a state where approval was denied.
+        APPROVED_CONCEPT: Marks approval at a conceptual level, potentially requiring further work.
+        UNDER_DEVELOPMENT: Represents an active development stage.
+        DEVELOPMENT_COMPLETE: Indicates development has been finalized.
+        APPROVED_FOR_DEPLOYMENT: Denotes readiness and approval for deployment.
+        STANDBY: Represents a state where the item is ready but not active.
+        ACTIVE: Denotes that the item or process is currently in operation.
+        FAILED: Indicates that the item or process has failed.
+        DISABLED: Represents a state where the item has been intentionally turned off or made inactive.
+        COMPLETE: Indicates that the item or process has been successfully completed.
+        DEPRECATED: Represents a state where the item is considered obsolete or no longer recommended.
+        OTHER: Refers to any state that is not explicitly defined within the enumeration.
+        DELETED: Indicates removal or deletion of the item.
+    """
+    UNKNOWN = "UNKNOWN"
+    DRAFT = "DRAFT"
+    PREPARED = "PREPARED"
+    PROPOSED = "PROPOSED"
+    APPROVED = "APPROVED"
+    REJECTED = "REJECTED"
+    APPROVED_CONCEPT = "APPROVED_CONCEPT"
+    UNDER_DEVELOPMENT = "UNDER_DEVELOPMENT"
+    DEVELOPMENT_COMPLETE = "DEVELOPMENT_COMPLETE"
+    APPROVED_FOR_DEPLOYMENT = "APPROVED_FOR_DEPLOYMENT"
+    STANDBY = "STANDBY"
+    ACTIVE = "ACTIVE"
+    FAILED = "FAILED"
+    DISABLED = "DISABLED"
+    COMPLETE = "COMPLETE"
+    DEPRECATED = "DEPRECATED"
+    OTHER = "OTHER"
+    DELETED = "DELETED"
+
+
+class SequencingOrder(StrEnum):
+    """
+    Defines different types of sequencing orders for data handling and processing.
+
+    This enumeration represents various possible orders for sequencing data. It
+    can be used to determine how a set of data should be sorted or processed
+    based on the specified order. The specific orders include universal identifiers
+    (GUID), creation metadata (recent or oldest), update metadata (recent or oldest),
+    and property-based sorting (ascending or descending).
+
+    Attributes:
+        ANY (str): Represents any sequencing order, providing no specific sorting.
+        GUID (str): Sorts based on globally unique identifiers.
+        CREATION_DATE_RECENT (str): Sorts by most recent creation date first.
+        CREATION_DATE_OLDEST (str): Sorts by oldest creation date first.
+        LAST_UPDATE_RECENT (str): Sorts by the most recent update date first.
+        LAST_UPDATE_OLDEST (str): Sorts by the oldest update date first.
+        PROPERTY_ASCENDING (str): Sorts by properties in ascending order.
+        PROPERTY_DESCENDING (str): Sorts by properties in descending order.
+    """
+    ANY = "ANY"
+    GUID = "GUID"
+    CREATION_DATE_RECENT = "CREATION_DATE_RECENT"
+    CREATION_DATE_OLDEST = "CREATION_DATE_OLDEST"
+    LAST_UPDATE_RECENT = "LAST_UPDATE_RECENT"
+    LAST_UPDATE_OLDEST = "LAST_UPDATE_OLDEST"
+    PROPERTY_ASCENDING = "PROPERTY_ASCENDING"
+    PROPERTY_DESCENDING = "PROPERTY_DESCENDING"
+
+
+class DeleteMethod(StrEnum):
+    LOOK_FOR_LINEAGE        = "LOOK_FOR_LINEAGE"
+    ARCHIVE                 = "ARCHIVE"
+    SOFT_DELETE             = "SOFT_DELETE"
+    PURGE                   = "PURGE"
+
+
+
+# Define the camelCase conversion function
+def to_camel_case(snake_str: str) -> str:
+    """
+    Converts a snake_case string to camelCase, with a special rule
+    to keep 'guid' (case-insensitive) as 'GUID' (all uppercase).
+    """
+    components = snake_str.split('_')
+    # Use a list comprehension to process each component
+    # The first component remains as is (lowercase)
+    # Subsequent components are capitalized, unless they are 'guid'
+    camel_case_components = []
+    for i, word in enumerate(components):
+        if word.lower() == 'guid':
+            camel_case_components.append('GUID')  # Special case: always uppercase GUID
+        elif i == 0:
+            camel_case_components.append(word)  # First word remains lowercase
+        else:
+            camel_case_components.append(word.capitalize())  # Subsequent words are capitalized
+    return ''.join(camel_case_components)
+
+
+class PyegeriaModel(BaseModel):
+    model_config = ConfigDict(
+        alias_generator=to_camel_case,
+        serialize_by_alias=True,
+        use_enum_values=True,
+        populate_by_name=True,  # Allow input by either field name or alias
+        extra='ignore',  
+        str_strip_whitespace=True
+        )
+
+
+class OpenMetadataRootProperties(PyegeriaModel):
+    effective_from: datetime| None = None
+    effective_to: datetime | None = None
+    type_name: str | None = None
+    extended_properties: dict | None = None
+
+
+class RelationshipBeanProperties(PyegeriaModel):
+    effective_from: datetime | None = None
+    effective_to: datetime | None = None
+    type_name: str = None
+    extended_properties: dict | None = None
+
+
+class ClassificationBeanProperties(PyegeriaModel):
+    effective_from: datetime | None = None
+    effective_to: datetime | None = None
+    type_name: str = None
+    extended_properties: dict | None = None
+
+
+class ReferenceableProperties(OpenMetadataRootProperties):
+    class_: str| None =  Field(alias="class"),
+    qualified_name: str
+    display_name: str
+    version_identifier: str | None = None
+    description: str | None = None
+    category: str | None = None
+    additional_properties: dict | None = None
+
+
+class RequestBody(PyegeriaModel):
+    external_source_guid: str | None = None
+    external_source_name: str | None = None
+    effective_time: datetime | None = None
+    governance_zone_filter: list[str] | None = None
+    for_lineage: bool | None = False
+    for_duplicate_processing: bool | None = False
+
+
+class NewRelationshipRequestBody(RequestBody):
+    class_: Annotated[Literal["NewRelationshipRequestBody"], Field(alias="class")]
+    make_anchor: bool | None = False
+    anchor_scope_guid: str | None = None
+    properties: RelationshipBeanProperties
+
+
+class DeleteRequestBody(RequestBody):
+    class_: Annotated[Literal["DeleteRequestBody"], Field(alias="class")]
+    cascaded_delete: bool | None = False
+    delete_method: DeleteMethod = DeleteMethod.LOOK_FOR_LINEAGE
+    archive_date: datetime | None = None
+    archive_process: str | None = None
+    archive_properties: dict | None = None
+
+
+class InitialClassifications(PyegeriaModel):
+    class_: str = Field(alias="class"),
+    other_props: Dict[str, Any] | None = None
+
+    @model_validator(mode="before")
+    @classmethod
+    def capture_other_props(cls, data: Dict[str, Any]) -> Dict[str, Any]:
+        captured_props = data.copy()
+
+        class_value = captured_props.pop("class", None)
+        other_props_dict = captured_props if captured_props else None
+        return {
+            "class_": class_value,
+            "other_props": other_props_dict
+            }
+
+
+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 = ValidStatusValues.ACTIVE
+    parent_guid: str | None = None
+    parent_relationship_type_name: str | None = None
+    parent_at_end_1: bool | None = True
+    properties: ReferenceableProperties
+
+
+class NewClassificationRequestBody(RequestBody):
+    class_: Annotated[Literal["NewClassificationRequestBody"], Field(alias="class")]
+    properties: ClassificationBeanProperties
+
+
+class UpdateClassificationRequestBody(RequestBody):
+    class_: Annotated[Literal["UpdateClassificationRequestBody"], Field(alias="class")]
+    properties: ClassificationBeanProperties
+    merge_update: bool | None = True
+
+
+class UpdateRelationshipRequestBody(RequestBody):
+    class_: Annotated[Literal["UpdateRelationshipRequestBody"], Field(alias="class")]
+    properties: RelationshipBeanProperties
+    merge_update: bool | None = True
+
+
+class TemplateRequestBody(PyegeriaModel):
+    class_: Annotated[Literal["TemplateRequestBody"], Field(alias="class")]
+    anchor_guid: str | None = None
+    is_own_anchor: bool | None = True
+    anchor_scope_guid: str | None = None
+    initial_classifications: dict | None = None  # unsure
+    parent_guid: str | None = None
+    parent_relationship_type_name: str | None = None
+    parent_at_end_1: bool | None = True
+    template_guid: str | None = None
+    replacement_properties: dict[str, Any] = {}
+    placeholder_properties: dict[str, Any] = {}
+
+
+class UpdateElementRequestBody(PyegeriaModel):
+    class_: Annotated[Literal["UpdateElementRequestBody"], Field(alias="class")]
+    properties: dict[str, Any] = {}
+    external_source_guid: dict[str, Any] = {}
+    external_source_name: dict[str, Any] = {}
+    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")]
+    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):
+    class_: Annotated[Literal["GetRequestBody"], Field(alias="class")]
+    metadata_elementtype__name: str | None = None
+    metadata_element_subtype_names: list[str] | None = None
+    skip_relationships: list[str] | None = None
+    include_only_relationships: list[str] | None = None
+    skip_classified_elements: list[str] | None = None
+    include_only_classified_elements: list[str] | None = None
+    graph_query_depth: int | None = None
+    governance_zone_filter: list[str]  | None= None
+    as_of_time: datetime | None = None
+    effective_time: datetime | None = None
+    for_lineage: bool | None = False
+    for_duplicate_processing: bool | None = False
+
+
+class ResultsRequestBody(GetRequestBody):
+    class_: Annotated[Literal["ResultsRequestBody"], Field(alias="class")]
+    limit_results_by_status: list[ValidStatusValues] | None= None
+    anchor_guid: str | None = None
+    sequencing_order: SequencingOrder | None = None
+    sequencing_property: str | None = None
+    start_from: int = 0
+    page_size: int = 0
+
+class FilterRequestBody(ResultsRequestBody):
+    class_: Annotated[Literal["FilterRequestBody"], Field(alias="class")]
+    filter: str
+
+
+class SearchStringRequestBody(ResultsRequestBody):
+    class_: Annotated[Literal["SearchStringRequestBody"], Field(alias="class")]
+    search_string: str | None = None
+    starts_with: bool = True
+    ends_with: bool = False
+    ignore_case: bool = False
+
+
+
+#######
+
+
+# --- Custom Base Model for JSON Key Conversion ---
+
+
+# --- Innermost Models ---
+
+class TypeInfo(PyegeriaModel):
+    """Represents the 'type' subsection."""
+    type_id: str
+    type_name: str
+    supertype__names: list[str] = None
+    type_version: int
+    type_description: str
+    type_category: str
+
+class OriginInfo(PyegeriaModel):
+    """Represents the 'origin' subsection."""
+    source_server: str
+    origin_category: str
+    home_metadata_collection_id: str
+    home_metadata_collection_name: str
+    license: list[str] = None # 'license' is optional in some origins
+
+class VersionInfo(PyegeriaModel):
+    """Represents the 'versions' subsection."""
+    created_by: str
+    updated_by: str
+    create_time: datetime
+    update_time: datetime
+    version: int
+
+class AnchorClassificationProperties(PyegeriaModel):
+    """Represents 'classificationProperties' for Anchor."""
+    anchortype__name: str
+    anchor_domain_name: str
+    anchor_scope_guid: list[str] = None # Varies between anchor and anchorScopeGUID
+    anchor_guid: list[str] = None # Used in Glossary anchor
+
+class SubjectAreaClassificationProperties(PyegeriaModel):
+    """Represents 'classificationProperties' for SubjectArea."""
+    display_name: list[str] = None
+    subject_area_name: list[str] = None
+
+class CanonicalVocabularyClassificationProperties(PyegeriaModel):
+    """Represents 'classificationProperties' for CanonicalVocabulary."""
+    scope: list[str] = None
+
+# Using Any for classificationProperties due to varying schemas, or a Union if all types are known
+class ElementClassification(PyegeriaModel):
+    """Represents 'ElementClassification' (used for anchor, subjectArea, otherClassifications)."""
+    class_: str = Field(alias="class") # Alias 'class' as it's a Python keyword
+    header_version: int
+    status: str
+    type_: TypeInfo = Field(alias="type") # Alias 'type' as it's a Python keyword
+    origin: OriginInfo
+    versions: VersionInfo
+    classification_origin: str
+    classification_name: str
+    # Use Any or a Union of specific property models if all types are known
+    classification_properties: Optional[Any] = None
+
+class CollectionProperties(PyegeriaModel):
+    """Represents the 'properties' subsection for GlossaryCategory."""
+    class_: str = Field(alias="class")
+    type_name: str
+    extended_properties: Optional[dict[str, Any]] = None
+    qualified_name: str
+    display_name: str
+    description: list[str] = None
+
+class GlossaryProperties(PyegeriaModel):
+    """Represents the 'properties' subsection for Glossary."""
+    display_name: str
+    qualified_name: str
+    usage: list[str] = None
+    description: list[str] = None
+    language: list[str] = None
+
+# --- Intermediate Models ---
+
+class ElementHeader(PyegeriaModel):
+    """Represents the 'elementHeader' and 'relationshipHeader' subsections."""
+    class_: str = Field(alias="class")
+    header_version: int
+    status: str
+    type_: TypeInfo = Field(alias="type")
+    origin: OriginInfo
+    versions: VersionInfo
+    guid: str
+    anchor: Optional[ElementClassification] = None
+    subject_area: Optional[ElementClassification] = Field(alias="subjectArea")
+    otherclass_ifications: list[ElementClassification] = Field(alias="otherClassifications")
+
+class RelatedElement(PyegeriaModel):
+    """Represents the 'relatedElement' subsection."""
+    element_header: ElementHeader = Field(alias="elementHeader")
+    properties: GlossaryProperties
+
+class AssociatedGlossaryItem(PyegeriaModel):
+    """Represents an item within the 'associatedGlossaries' list."""
+    relationship_header: ElementHeader = Field(alias="relationshipHeader")
+    related_element: RelatedElement = Field(alias="relatedElement")
+    related_element_at_end1: Optional[bool] = Field(alias="relatedElementAtEnd1")
+
+# --- Root Model ---
+
+class OpenMetadataRootElement(PyegeriaModel):
+    """Represents the main object in the JSON array."""
+    class_: str = Field(alias="class")
+    element_header: ElementHeader = Field(alias="elementHeader")
+    associated_glossaries: list[AssociatedGlossaryItem] = Field(alias="associatedGlossaries")
+    mermaid_graph: list[str] = Field(alias="mermaidGraph")
+    properties: CollectionProperties
+
+# --- Overall Payload Type ---
+# The entire JSON is a list of OpenMetadataRootElement
+OpenMetadataPayload = list[OpenMetadataRootElement]