kodexa 7.0.1a9987865527__py3-none-any.whl → 7.0.1a11915814268__py3-none-any.whl

kodexa/model/objects.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Optional, List, Dict, Any
+from typing import Union
 
 from pydantic import AnyUrl, Field, RootModel, BaseModel, ConfigDict
 
@@ -628,9 +629,11 @@ class ProjectGuidance(BaseModel):
     slug: Optional[str] = None
     name: Optional[str] = None
     description: Optional[str] = None
+    guidance: Optional[List[Guidance]] = Field(None)
+    active_store: bool = Field(False, alias="activeStore")
+    storage: GuidanceSetStorage = Field(None, description="The storage for the guidance set")
     template_ref: Optional[str] = Field(None, alias="templateRef")
     ref: Optional[str] = None
-    guidance: Optional[List[Guidance]] = Field(None, alias="guidance")
 
 
 class ProjectDashboard(BaseModel):
@@ -705,9 +708,8 @@ class ProjectStore(BaseModel):
         None, description="Show thumbnails in dtore", alias="showThumbnails"
     )
 
-    showSearch: Optional[bool] = Field(
-        None, description="Show search in store", alias="showSearch"
-    )
+    document_properties: Optional[List[Option]] = Field(None, alias="documentProperties")
+    label_expressions: Optional[List[LabelExpression]] = Field(None, alias="labelExpressions")
 
     allowDataEditing: Optional[bool] = Field(
         None, description="Allow data editing", alias="allowDataEditing"
@@ -820,6 +822,7 @@ class SelectionOption(BaseModel):
     label: Optional[str] = None
     id: Optional[str] = None
     description: Optional[str] = None
+    lexical_relations: Optional[List[LexicalRelation]] = Field([], alias="lexicalRelations")
 
 
 class SlugBasedMetadata1(BaseModel):
@@ -986,6 +989,8 @@ class ValuePath(Enum):
     script = "SCRIPT"
     derived = "DERIVED"
     formula = "FORMULA"
+    review = "REVIEW"
+    external = "EXTERNAL"
 
 
 class MetadataValue(Enum):
@@ -1504,7 +1509,7 @@ class ProjectMetadata(BaseModel):
         arbitrary_types_allowed=True,
         protected_namespaces=("model_config",),
     )
-    tags: Optional[List[str]] = Field(default_factory=list, set=True)
+    tags: Optional[List[str]] = Field(default_factory=list)
 
 
 class State1(Enum):
@@ -2269,7 +2274,7 @@ class DockerSource(ExtensionPackSource):
     location: Optional[str] = None
 
 
-class DocumentMetadataDefaults(BaseModel):
+class LabelExpression(BaseModel):
     """
 
     """
@@ -2279,9 +2284,22 @@ class DocumentMetadataDefaults(BaseModel):
         arbitrary_types_allowed=True,
         protected_namespaces=("model_config",),
     )
-    document_metadata_properties: Optional[List[DocumentMetadataProperty]] = Field(
-        None, alias="documentMetadataProperties"
+    expression: Optional[str] = None
+    label: Optional[str] = None
+
+
+class DocumentMetadataDefaults(BaseModel):
+    """
+
+    """
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
     )
+    document_properties: Optional[List[Option]] = Field(None, alias="documentProperties")
+    label_expressions: Optional[List[LabelExpression]] = Field(None, alias="labelExpressions")
 
 
 class ExtensionPackProvided(BaseModel):
@@ -2507,7 +2525,74 @@ class ProjectAssistant(BaseModel):
     assistant_role: Optional[str] = Field(None, alias="assistantRole")
 
 
+class LexicalRelationType(Enum):
+    SYNONYM = "SYNONYM"
+    ANTONYM = "ANTONYM"
+    HYPERNYM = "HYPERNYM"
+    HYPONYM = "HYPONYM"
+    MERONYM = "MERONYM"
+    HOLONYM = "HOLONYM"
+    ENTAILMENT = "ENTAILMENT"
+    SIMILAR_TO = "SIMILAR_TO"
+    OTHER = "OTHER"
+
+
+class LexicalRelation(BaseModel):
+    type: Optional[LexicalRelationType] = None
+    value: Optional[str] = None
+    weight: Optional[float] = None
+
+
+class TaxonValuePath(Enum):
+    VALUE_OR_ALL_CONTENT = "VALUE_OR_ALL_CONTENT"
+    VALUE_ONLY = "VALUE_ONLY"
+    ALL_CONTENT = "ALL_CONTENT"
+    DATA_PATH = "DATA_PATH"
+    METADATA = "METADATA"
+    EXPRESSION = "EXPRESSION"
+    SCRIPT = "SCRIPT"
+    FORMULA = "FORMULA"
+    DERIVED = "DERIVED"
+    REVIEW = "REVIEW"
+    EXTERNAL = "EXTERNAL"
+
+
+class TaxonCardinality(Enum):
+    ONCE_PER_DOCUMENT = "ONCE_PER_DOCUMENT"
+    MULTIPLE_PER_DOCUMENT = "MULTIPLE_PER_DOCUMENT"
+    ONCE_PER_SEGMENT = "ONCE_PER_SEGMENT"
+    MULTIPLE_PER_SEGMENT = "MULTIPLE_PER_SEGMENT"
+
+
+class TaxonAdditionContextType(str, Enum):
+    RECORD_DEFINITION = "RECORD_DEFINITION"
+    RECORD_SECTION_STARTER_MARKER = "RECORD_SECTION_STARTER_MARKER"
+    RECORD_SECTION_END_MARKER = "RECORD_SECTION_END_MARKER"
+    RECORD_START_MARKER = "RECORD_START_MARKER"
+    RECORD_END_MARKER = "RECORD_END_MARKER"
+
+
+class TaxonAdditionContext(BaseModel):
+    type: TaxonAdditionContextType
+    context: str
+    weight: Optional[float] = None
+    negative: Optional[bool] = None
+
+
+class TaxonGuideProperties(BaseModel):
+    guidance_key: Optional[bool] = Field(None, alias="guidanceKey")
+    guidance_key_expression: Optional[str] = Field(None, alias="guidanceKeyExpression")
+    use_guidance_for_classification: Optional[bool] = Field(None, alias="useGuidanceForClassification")
+    if_present_required: Optional[bool] = Field(None, alias="ifPresentRequired")
+
 class TaxonConditionalFormat(BaseModel):
+    type: Optional[str] = None
+    condition: Optional[str] = None
+    properties: Dict[str, Any] = Field(default_factory=dict)
+
+
+class TaxonValidation(BaseModel):
+
     model_config = ConfigDict(
         populate_by_name=True,
         use_enum_values=True,
@@ -2515,183 +2600,134 @@ class TaxonConditionalFormat(BaseModel):
         protected_namespaces=("model_config",),
     )
 
-    type: Optional[str] = None
-    condition: Optional[str] = None
-    properties: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    name: Optional[str] = Field(None)
+    description: Optional[str] = Field(None)
+    rule_formula: Optional[str] = Field(None, alias="ruleFormula")
+    message_formula: Optional[str] = Field(None, alias="messageFormula")
+    detail_formula: Optional[str] = Field(None, alias="detailFormula")
+    exception_id: Optional[str] = Field(None, alias="exceptionId")
+    support_article_id: Optional[str] = Field(None, alias="supportArticleId")
+    overridable: Optional[bool] = None
 
 
-class TaxonCardinality(Enum):
-    once_per_document = "ONCE_PER_DOCUMENT"
-    multiple_per_document = "MULTIPLE_PER_DOCUMENT"
-    once_per_segment = "ONCE_PER_SEGMENT"
-    multiple_per_segment = "MULTIPLE_PER_SEGMENT"
+class DocumentTaxonValidation(BaseModel):
 
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
 
-class Taxon(BaseModel):
-    """
+    taxonomy_ref: Optional[str] = Field(None, alias="taxonomyRef")
+    taxon_path: Optional[str] = Field(None, alias="taxonPath")
+    validation: Optional[TaxonValidation] = None
 
-    """
+
+class Taxon(BaseModel):
     model_config = ConfigDict(
         populate_by_name=True,
         use_enum_values=True,
         arbitrary_types_allowed=True,
         protected_namespaces=("model_config",),
     )
-    """
-    A taxon is an individual label within a taxonomy
-    """
 
-    id: Optional[str] = Field(None, description="The ID of the taxon")
-    label: Optional[str] = Field(None, description="The text to display for this taxon")
-    generate_name: Optional[bool] = Field(
-        None,
-        alias="generateName",
-        description="Is the name generated, this allows that you can change displays without impacted existing content",
-    )
-    group: Optional[bool] = Field(
-        None,
-        description="Is this taxon a group, and therefore can't have a value, can only have children",
-    )
-    name: str = Field(
-        ..., description="The name to be used", pattern=r"^[a-zA-Z0-9\-_]{0,255}$"
-    )
-    external_name: Optional[str] = Field(
-        None,
-        alias="externalName",
-        description="The name to be used when we are publishing this taxon to external systems",
-    )
-    value_path: Optional[ValuePath] = Field(
-        None,
-        alias="valuePath",
-        description="Where to get the value for this taxon when extracting",
-    )
-    metadata_value: Optional[MetadataValue] = Field(
-        None,
-        alias="metadataValue",
-        description="If the type is metadata this will be the metadata option",
-    )
-    data_path: Optional[str] = Field(
-        None,
-        alias="dataPath",
-        description="The path to the data, based on the data inside the label (tag) within the document",
-    )
-    expression: Optional[str] = Field(
-        None,
-        description="If the taxon is based on expression, this is the expression based on the available objects",
-    )
-    enable_fallback_expression: Optional[bool] = Field(
-        None,
-        alias="enableFallbackExpression",
-        description="Allow for the use of a fallback expression if the taxon wasn't found",
-    )
-    fallback_expression: Optional[str] = Field(
-        None,
-        alias="fallbackExpression",
-        description="Fallback expression if enabled, this is the expression based on the available objects",
-    )
-    nullable: Optional[bool] = Field(
-        None, description="Determine if the value of the taxon can be null (unknown)"
-    )
-    null_value: Optional[str] = Field(
-        None,
-        alias="nullValue",
-        description="Allows the setting of a value to replace null if the taxon is nullable",
-    )
-    description: Optional[str] = Field(None, description="The description of the taxon")
+    id: Optional[str] = None
+    label: Optional[str] = None
+    generate_name: Optional[bool] = Field(None, alias="generateName")
+    group: Optional[bool] = None
+    name: str = Field(..., pattern=r"^[a-zA-Z0-9\-_]{0,255}$")
+    select_weight: Optional[int] = Field(1, alias="selectWeight")
+    external_name: Optional[str] = Field(None, alias="externalName")
+    value_path: Optional[TaxonValuePath] = Field(None, alias="valuePath")
+    metadata_value: Optional[MetadataValue] = Field(None, alias="metadataValue")
+    data_path: Optional[str] = Field(None, alias="dataPath")
+    expression: Optional[str] = None
+    enable_fallback_expression: Optional[bool] = Field(None, alias="enableFallbackExpression")
+    fallback_expression: Optional[str] = Field(None, alias="fallbackExpression")
+    nullable: Optional[bool] = None
+    null_value: Optional[str] = Field(None, alias="nullValue")
+    denormalize_to_children: Optional[bool] = Field(False, alias="denormalizeToChildren")
+    not_user_labelled: Optional[bool] = Field(False, alias="notUserLabelled")
+    description: Optional[str] = None
     overview_markdown: Optional[str] = Field(None, alias="overviewMarkdown")
-    enabled: Optional[bool] = Field(
-        None, description="Is the taxon enabled (used in the UI)"
-    )
-    color: Optional[str] = Field(
-        None, description="Hex encoding of the color to use for the taxon"
-    )
-    children: Optional[List[Taxon]] = Field(
-        None, description="The children under this taxon"
-    )
-    options: Optional[List[Option]] = Field(
-        None,
-        description="Options that can be shown for the taxon (usually used in assistant taxonomies)",
-    )
-    related_taxons: Optional[List[RelatedTaxon]] = Field(
-        None,
-        alias="relatedTaxons",
-        description="A list of relationships to other taxons and the purpose of the relationship",
-    )
-    node_types: Optional[List[str]] = Field(
-        None,
-        alias="nodeTypes",
-        description="A list of the node types that this taxon applies to (empty means everything), used in the UI",
-    )
-    taxon_type: Optional[TaxonType] = Field(
-        None,
-        alias="taxonType",
-        description="Expected data type to coalesce to (defaults to STRING)",
-    )
-    selection_options: Optional[List[SelectionOption]] = Field(
-        None,
-        alias="selectionOptions",
-        description="If data type is SELECTION, this is the list of available options",
-    )
-    type_features: Optional[Dict[str, Any]] = Field(
-        None,
-        alias="typeFeatures",
-        description="Additional features for the type handling",
-    )
-    path: Optional[str] = Field(None, description="The path to the node")
-    multi_value: Optional[bool] = Field(
-        None, alias="multiValue", description="Does this taxon allow multiple values"
-    )
-    user_editable: Optional[bool] = Field(
-        None,
-        alias="userEditable",
-        description="Can the value of this taxon be edited by a user",
-    )
-    denormalize_to_children: Optional[bool] = Field(
-        None,
-        alias="denormalizeToChildren",
-        description="Should the value of this taxon be denormalized to the children",
-    )
-    not_user_labelled: Optional[bool] = Field(
-        None,
-        alias="notUserLabelled",
-        description="The taxon is not user labelled",
-    )
-    use_post_expression: Optional[bool] = Field(
-        None, alias="usePostExpression", description="Use a post extraction expression"
-    )
-    post_expression: Optional[str] = Field(
-        None,
-        alias="postExpression",
-        description="An expression that is applied post extraction of the data",
-    )
-    semantic_definition: Optional[str] = Field(
-        None,
-        alias="semanticDefinition",
-        description="The semantic definition of the taxon",
-    )
-    examples: Optional[List[GuidanceTagResult]] = Field(
-        None,
-        description="A list of examples of the taxon values, used to understand the taxon",
-    )
-
-    synonyms: Optional[List[str]] = Field(
-        None,
-        description="A list of synonyms of the taxon values, used to understand the taxon",
+    semantic_definition: Optional[str] = Field(None, alias="semanticDefinition")
+    synonyms: Optional[List[str]] = None
+    lexical_relations: Optional[List[LexicalRelation]] = Field([], alias="lexicalRelations")
+    addition_contexts: Optional[List[TaxonAdditionContext]] = Field([], alias="additionContexts")
+    guide_properties: Optional[TaxonGuideProperties] = Field(None, alias="guideProperties")
+    enabled: Optional[bool] = True
+    color: Optional[str] = None
+    children: Optional[List['Taxon']] = Field(default_factory=list)
+    options: Optional[List[Any]] = Field(default_factory=list)
+    node_types: Optional[List[str]] = Field(default_factory=list, alias="nodeTypes")
+    taxon_type: Optional[TaxonType] = Field("STRING", alias="taxonType")
+    selection_options: Optional[List[SelectionOption]] = Field(default_factory=list, alias="selectionOptions")
+    type_features: Optional[Dict[str, Any]] = Field(default_factory=dict, alias="typeFeatures")
+    properties: Optional[Dict[str, Any]] = Field(default_factory=dict)
+    conditional_formats: Optional[List[TaxonConditionalFormat]] = Field(default_factory=list,
+                                                                        alias="conditionalFormats")
+    validation_rules: List[TaxonValidation] = Field(
+        default_factory=list,
+        description="The validation rules for the taxon"
     )
 
     cardinality: Optional[TaxonCardinality] = None
+    path: Optional[str] = None
+    multi_value: Optional[bool] = Field(True, alias="multiValue")
+    user_editable: Optional[bool] = Field(True, alias="userEditable")
+    use_post_expression: Optional[bool] = Field(False, alias="usePostExpression")
+    post_expression: Optional[str] = Field(None, alias="postExpression")
+
+    def update_path(self, parent_path=""):
+        self.path = parent_path + "/" + self.name if parent_path else self.name
+        if self.children:
+            for child in self.children:
+                child.update_path(self.path)
 
-    conditional_formats: Optional[List[TaxonConditionalFormat]] = Field(None, alias="conditionalFormats")
-
-    checklist_definitions: Optional[List[ChecklistDefinition]] = Field(None, alias="checklistDefinitions")
-
-    def update_path(self, parent_path=None):
-        if parent_path is None:
-            parent_path = ""
-        self.path = parent_path + self.name
-        if self.children is not None:
+    def find_taxon(self, *path_parts):
+        if not path_parts:
+            return None
+        if self.name == path_parts[0] and len(path_parts) == 1:
+            return self
+        else:
+            remaining_parts = path_parts[1:]
             for child in self.children:
-                child.update_path(self.path + "/")
+                hit = child.find_taxon(*remaining_parts)
+                if hit:
+                    return hit
+        return None
+
+    def groups(self):
+        groups = []
+        if self.group:
+            groups.append(self)
+        for child in self.children:
+            groups.extend(child.groups())
+        return groups
+
+    def all_groups(self):
+        groups = []
+        if self.group:
+            groups.append(self)
+        for child in self.children:
+            groups.extend(child.all_groups())
+        return groups
+
+    def get_simplified_structure(self):
+        structure = {
+            "label": self.label,
+            "description": self.description,
+        }
+        if self.group:
+            structure["group"] = True
+            structure["path"] = self.path
+            structure["children"] = [child.get_simplified_structure() for child in self.children]
+        else:
+            structure["group"] = False
+            structure["tag"] = self.name
+            structure["taxonType"] = self.taxon_type
+        return structure
 
 
 class ContentObject(BaseModel):
@@ -2881,6 +2917,59 @@ class Project(BaseModel):
     options: Optional[ProjectOptions] = Field(None, alias="options")
 
 
+class TaskStatus(str, Enum):
+    TODO = "TODO"
+    IN_PROGRESS = "IN_PROGRESS"
+    DONE = "DONE"
+
+
+class TaskCheckItem(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    name: str
+    description: Optional[str] = None
+    taxon_path: Optional[str] = Field(None, alias="taxonPath")
+    taxonomy_ref: Optional[str] = Field(None, alias="taxonomyRef")
+
+
+class TaskMetadata(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    field_values: Dict[str, Any] = Field(default_factory=dict)
+    fields: List[Option] = Field(default_factory=list)
+    check_items: List[TaskCheckItem] = Field(default_factory=list)
+    document_store_ref: Optional[str] = None
+
+
+class Task(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    project: Optional['Project'] = Field(None)
+    title: Optional[str] = Field(None)
+    template: Optional[bool] = Field(None)
+    description: Optional[str] = Field(None)
+    metadata: Optional['TaskMetadata'] = Field(None)
+    due_date: Optional[StandardDateTime] = Field(None, alias="dueDate")
+    completed_date: Optional[StandardDateTime] = Field(None, alias="completedDate")
+    status: Optional['TaskStatus'] = Field(None)
+    assignee: Optional['User'] = Field(None)
+
+
 class FeatureSet(BaseModel):
     """
 
@@ -3377,6 +3466,28 @@ class PageProject(BaseModel):
     empty: Optional[bool] = None
 
 
+class PageRetainedGuidance(BaseModel):
+    """
+
+    """
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    size: Optional[int] = None
+    content: Optional[List[RetainedGuidance]] = None
+    number: Optional[int] = None
+
+    number_of_elements: Optional[int] = Field(None, alias="numberOfElements")
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+    empty: Optional[bool] = None
+
+
 class PageAssistant(BaseModel):
     """
 
@@ -3443,6 +3554,28 @@ class PageMessage(BaseModel):
     empty: Optional[bool] = None
 
 
+class PageTask(BaseModel):
+    """
+
+    """
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    total_pages: Optional[int] = Field(None, alias="totalPages")
+    total_elements: Optional[int] = Field(None, alias="totalElements")
+    size: Optional[int] = None
+    content: Optional[List[Task]] = None
+    number: Optional[int] = None
+
+    number_of_elements: Optional[int] = Field(None, alias="numberOfElements")
+    first: Optional[bool] = None
+    last: Optional[bool] = None
+    empty: Optional[bool] = None
+
+
 class PageChannel(BaseModel):
     """
 
@@ -3882,6 +4015,45 @@ class DocumentExternalData(BaseModel):
     document_family: Optional[DocumentFamily] = Field(None, alias="documentFamily")
 
 
+class RetainedGuidance(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+    id: Optional[str] = Field(None)
+    uuid: Optional[str] = None
+    change_sequence: Optional[int] = Field(None, alias="changeSequence")
+    created_on: Optional[StandardDateTime] = Field(None, alias="createdOn")
+    updated_on: Optional[StandardDateTime] = Field(None, alias="updatedOn")
+    guidance_embeddings: List["GuidanceEmbedding"] = Field(default_factory=list, alias="guidanceEmbeddings")
+    guidance_set_ref: str = Field(..., alias="guidanceSetRef")
+    guidance_type: Optional[str] = Field(None, alias="guidanceType")
+    guidance_key: Optional[str] = Field(None, alias="guidanceKey")
+    taxonomy_ref: Optional[str] = Field(None, alias="taxonomyRef")
+    taxon_path: Optional[str] = Field(None, alias="taxonPath")
+    document_family_id: Optional[str] = Field(None, alias="documentFamilyId")
+    guidance_text: Optional[str] = Field(None, alias="guidanceText")
+    summary: Optional[str] = None
+    guidance_response: Dict[str, Any] = Field(default_factory=dict, alias="guidanceResponse")
+    legacy_guidance: Optional[Guidance] = Field(None, alias="legacyGuidance")
+    active: bool = True
+    taxon_snapshots: List[Taxon] = Field(default_factory=list, alias="taxonSnapshots")
+
+
+class GuidanceEmbedding(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    retained_guidance: Optional[RetainedGuidance] = Field(None, alias="retainedGuidance")
+    # Add other fields as needed
+
+
 class DocumentFamily(BaseModel):
     """
 
@@ -3964,6 +4136,11 @@ class DocumentFamily(BaseModel):
         description="The statistics about the labels in the document family",
     )
 
+    guidance: Optional[bool] = Field(
+        None,
+        description="Indicates whether guidance is available for this document family",
+    )
+
 
 class DocumentFamilyStatistics(BaseModel):
     """
@@ -4341,39 +4518,86 @@ class UserSelection(BaseModel):
     line_uuid: Optional[str] = Field(None, alias="lineUuid")
 
 
+class GuidanceRelationEmbedding(BaseModel):
+
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    relation: Optional[str] = None
+    model_id: Optional[str] = Field(None, alias="modelId")
+    embedding: Optional[List[float]] = None
+
+
 class Guidance(BaseModel):
     id: Optional[str] = Field(None, description="The ID of the guidance")
     name: Optional[str] = None
     guidance_type: Optional[str] = Field(None, alias="guidanceType")
+    guidance_key: Optional[str] = Field(None, alias="guidanceKey")
     taxonomy_ref: Optional[str] = Field(None, alias="taxonomyRef")
+    taxon_path: Optional[str] = Field(None, alias="taxonPath")
+    document_family_id: Optional[str] = Field(None, alias="documentFamilyId")
     document_name: Optional[str] = Field(None, alias="documentName")
-    document_type: Optional[str] = Field(None, alias="documentType")
     document_page: Optional[int] = Field(None, alias="documentPage")
-    sample_text: Optional[str] = Field(None, alias="sampleText")
-    sample_result: Optional[Dict[str, List[GuidanceTagResult]]] = Field(None, alias="sampleResult")
-    section_markers: Optional[List[GuidanceTagResult]] = Field(None, alias="sectionMarkers")
-    active: Optional[bool] = None
+    guidance_text: Optional[str] = Field(None, alias="guidanceText")
+    relation_embeddings: Optional[List[GuidanceRelationEmbedding]] = Field([], alias="relationEmbeddings")
+    summary: Optional[str] = None
+    guidance_response: Optional[Dict[str, Any]] = Field(None, alias="guidanceResponse")
+    active: Optional[bool] = True
     applicable_tags: Optional[List[str]] = Field(None, alias="applicableTags")
+    required_tags: Optional[List[str]] = Field(None, alias="requiredTags")
     priority: Optional[int] = 1
     user_instructions: Optional[str] = Field(None, alias="userInstructions")
     user_instructions_properties: Optional[Dict[str, Any]] = Field(None, alias="userInstructionsProperties")
+    user_id: Optional[str] = Field(None, alias="userId")
     created: Optional[StandardDateTime] = None
     updated: Optional[StandardDateTime] = None
-    userId: Optional[str] = Field(None, alias="userId")
-
-    # users selected text, text and line_uuid
     user_selection: Optional[List[UserSelection]] = Field(None, alias="userSelection")
-
     compiled_guidance: Optional[Dict[str, Any]] = Field(None, alias="compiledGuidance")
-
     guidance_options: Optional[List[Option]] = Field(None, alias="guidanceOptions")
 
 
+class GuidanceEmbeddingType(Enum):
+    SUMMARY = "SUMMARY"
+    CONTENT = "CONTENT"
+    TFIDF = "TFIDF"
+
+
+class GuidanceSetStorage(BaseModel):
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    summarize_model_id: Optional[str] = Field(None, alias="summarizeModelId")
+    summarize_prompt: Optional[str] = Field(None, alias="summarizePrompt")
+    embedding_model_id: Optional[str] = Field(None, alias="embeddingModelId")
+    embedding_types: List[GuidanceEmbeddingType] = Field(default_factory=list, alias="embeddingTypes")
+
+
 class GuidanceSet(ExtensionPackProvided):
     """
-
+    A guidance set is a list of guidance objects that can be applied to a taxonomy
     """
-    guidance: List[Guidance] = Field(None, description="The guidance in the set")
+    model_config = ConfigDict(
+        populate_by_name=True,
+        use_enum_values=True,
+        arbitrary_types_allowed=True,
+        protected_namespaces=("model_config",),
+    )
+
+    active_store: bool = Field(False, alias="activeStore",
+                               description="If true, allows guidance to be stored through the API")
+    storage: GuidanceSetStorage = Field(default_factory=GuidanceSetStorage)
+    guidance: List[Guidance] = Field(default_factory=list, description="The guidance in the set")
+
+    def get_type(self) -> str:
+        return "guidance"
 
 
 class PageGuidanceSet(BaseModel):
@@ -5059,10 +5283,6 @@ class ModelContentMetadata(BaseModel):
         None, alias="eventAware", description="Is this model event aware"
     )
 
-    atomic: Optional[bool] = Field(
-        None, description="Is the model uploaded/downloaded atomically"
-    )
-
     use_implementation_from_template: Optional[bool] = Field(
         None,
         alias="useImplementationFromTemplate",
@@ -5448,6 +5668,11 @@ class Taxonomy(ExtensionPackProvided):
         alias="totalTaxons",
         description="The total number of taxons in the taxonomy",
     )
+    external_data_taxonomy_refs: Optional[list[str]] = Field(
+        None,
+        alias="externalDataTaxonomyRefs",
+        description="A list of references to an external data taxonomy",
+    )
 
     def update_paths(self):
         for taxon in self.taxons: