cognite-toolkit 0.5.44__py3-none-any.whl → 0.7.34__py3-none-any.whl

cognite_toolkit/_cdf_tk/resource_classes/view_field_definitions.py

@@ -0,0 +1,207 @@
+import re
+import sys
+from types import MappingProxyType
+from typing import Any, ClassVar, Literal, cast
+
+from pydantic import Field, ModelWrapValidatorHandler, model_serializer, model_validator
+from pydantic_core.core_schema import SerializerFunctionWrapHandler
+
+from cognite_toolkit._cdf_tk.constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    SPACE_FORMAT_PATTERN,
+)
+from cognite_toolkit._cdf_tk.utils.collection import humanize_collection
+
+from .base import BaseModelResource
+from .container_field_definitions import ContainerReference
+
+if sys.version_info < (3, 11):
+    from typing_extensions import Self
+else:
+    from typing import Self
+
+KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
+
+
+class ViewReference(BaseModelResource, populate_by_name=True):
+    type: Literal["view"] = "view"
+    space: str = Field(
+        description="Id of the space that the view belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the view.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the view.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+
+
+class DirectRelationReference(BaseModelResource):
+    space: str = Field(
+        description="Id of the space that the instance belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the instance.",
+        min_length=1,
+        max_length=255,
+    )
+
+
+class ThroughRelationReference(BaseModelResource):
+    source: ViewReference | ContainerReference = Field(
+        description="Reference to the view or container from where this relation is inherited.",
+    )
+    identifier: str = Field(
+        description="Identifier of the relation in the source view or container.",
+        min_length=1,
+        max_length=255,
+    )
+
+
+class ViewProperty(BaseModelResource):
+    name: str | None = Field(
+        default=None,
+        description="Name of the property.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the content and suggested use for this property..",
+        max_length=1024,
+    )
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def find_property_type_cls(cls, data: Any, handler: ModelWrapValidatorHandler[Self]) -> Self:
+        if isinstance(data, ViewProperty):
+            return cast(Self, data)
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid property type data '{type(data)}' expected dict")
+
+        if cls is not ViewProperty:
+            data_copy = dict(data)
+            if cls in _CONNECTION_DEFINITION_CLASS_BY_TYPE.values():
+                data_copy.pop("connectionType", None)
+            return handler(data_copy)
+
+        cls_: type[ContainerViewProperty] | type[ConnectionDefinition]
+        if "container" in data:
+            cls_ = ContainerViewProperty
+        elif "connectionType" in data:
+            connection_type = data.get("connectionType")
+            if connection_type is None:
+                raise ValueError("Missing 'connectionType' field in connection definition data")
+            if connection_type not in _CONNECTION_DEFINITION_CLASS_BY_TYPE:
+                raise ValueError(
+                    f"invalid connection type '{connection_type}'. Expected one of {humanize_collection(_CONNECTION_DEFINITION_CLASS_BY_TYPE.keys(), bind_word='or')}"
+                )
+            cls_ = _CONNECTION_DEFINITION_CLASS_BY_TYPE[connection_type]
+        else:
+            raise ValueError(
+                "Invalid Property data. If it is a connection definition, it must contain 'connectionType' field. If it is a view property, it must contain 'container' and 'containerPropertIdentifier' field."
+            )
+
+        data_copy = dict(data)
+        data_copy.pop("connectionType", None)
+        return cast(Self, cls_.model_validate(data_copy))
+
+    @model_serializer(mode="wrap", when_used="always", return_type=dict)
+    def serialize_property_type(self, handler: SerializerFunctionWrapHandler) -> dict:
+        serialized_data = handler(self)
+        if hasattr(self, "connection_type"):
+            serialized_data["connectionType"] = self.__class__.connection_type
+        return serialized_data
+
+
+class ContainerViewProperty(ViewProperty):
+    container: ContainerReference = Field(
+        description="Reference to the container where this property is defined.",
+    )
+    container_property_identifier: str = Field(
+        description="Identifier of the property in the container.",
+        min_length=1,
+        max_length=255,
+        pattern=CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    )
+    source: ViewReference | None = Field(
+        default=None,
+        description="Indicates on what type a referenced direct relation is expected to be. Only applicable for direct relation properties.",
+    )
+
+
+class ConnectionDefinition(ViewProperty):
+    connection_type: ClassVar[str]
+    source: ViewReference = Field(
+        description="Indicates the view which is either the target node(s) or the node(s) containing the direct relation property."
+    )
+
+
+class EdgeConnectionDefinition(ConnectionDefinition):
+    connection_type: ClassVar[Literal["single_edge_connection", "multi_edge_connection"]]
+    type: DirectRelationReference = Field(
+        description="Reference to the node pointed to by the direct relation.",
+    )
+    edge_source: ViewReference | None = Field(
+        default=None,
+        description="Reference to the view from where this edge connection is inherited.",
+    )
+    direction: Literal["outwards", "inwards"]
+
+
+class SingleEdgeConnectionDefinition(EdgeConnectionDefinition):
+    connection_type = "single_edge_connection"
+
+
+class MultiEdgeConnectionDefinition(EdgeConnectionDefinition):
+    connection_type = "multi_edge_connection"
+
+
+class ReverseDirectRelationConnectionDefinition(ConnectionDefinition):
+    connection_type: ClassVar[Literal["single_reverse_direct_relation", "multi_reverse_direct_relation"]]
+    through: ThroughRelationReference = Field(
+        description="The view or container of the node containing the direct relation property.",
+    )
+
+
+class SingleReverseDirectRelationConnectionDefinition(ReverseDirectRelationConnectionDefinition):
+    connection_type = "single_reverse_direct_relation"
+
+
+class MultiReverseDirectRelationConnectionDefinition(ReverseDirectRelationConnectionDefinition):
+    connection_type = "multi_reverse_direct_relation"
+
+
+def get_connection_definition_type_leaf_classes(base_class: type[ConnectionDefinition]) -> list:
+    subclasses = base_class.__subclasses__()
+    result = []
+
+    if not subclasses:
+        if base_class is not ConnectionDefinition:
+            result.append(base_class)
+    else:
+        for subclass in subclasses:
+            result.extend(get_connection_definition_type_leaf_classes(subclass))
+
+    return result
+
+
+_CONNECTION_DEFINITION_CLASS_BY_TYPE: MappingProxyType[str, type[ConnectionDefinition]] = MappingProxyType(
+    {
+        c.connection_type: c
+        for c in get_connection_definition_type_leaf_classes(ConnectionDefinition)
+        if hasattr(c, "connection_type") and c.connection_type is not None
+    }
+)

cognite_toolkit/_cdf_tk/resource_classes/views.py

@@ -0,0 +1,93 @@
+import re
+from typing import Any
+
+from pydantic import Field, field_validator, model_serializer
+from pydantic_core.core_schema import SerializationInfo, SerializerFunctionWrapHandler
+
+from cognite_toolkit._cdf_tk.constants import (
+    CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN,
+    DM_EXTERNAL_ID_PATTERN,
+    DM_VERSION_PATTERN,
+    FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS,
+    FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER,
+    SPACE_FORMAT_PATTERN,
+)
+from cognite_toolkit._cdf_tk.utils.collection import humanize_collection
+
+from .base import ToolkitResource
+from .view_field_definitions import ViewProperty, ViewReference
+
+KEY_PATTERN = re.compile(CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER_PATTERN)
+
+
+class ViewYAML(ToolkitResource):
+    space: str = Field(
+        description="Id of the space that the view belongs to.",
+        min_length=1,
+        max_length=43,
+        pattern=SPACE_FORMAT_PATTERN,
+    )
+    external_id: str = Field(
+        description="External-id of the view.",
+        min_length=1,
+        max_length=255,
+        pattern=DM_EXTERNAL_ID_PATTERN,
+    )
+    version: str = Field(
+        description="Version of the view.",
+        max_length=43,
+        pattern=DM_VERSION_PATTERN,
+    )
+    name: str | None = Field(
+        default=None,
+        description="name for the view.",
+        max_length=255,
+    )
+    description: str | None = Field(
+        default=None,
+        description="Description of the view.",
+        max_length=1024,
+    )
+    filter: dict[str, Any] | None = Field(
+        default=None,
+        description="A filter Domain Specific Language (DSL) used to create advanced filter queries.",
+    )
+    implements: list[ViewReference] | None = Field(
+        default=None,
+        description="References to the views from where this view will inherit properties.",
+    )
+    properties: dict[str, ViewProperty] | None = Field(
+        default=None, description="Set of properties to apply to the View."
+    )
+
+    @field_validator("external_id")
+    @classmethod
+    def check_forbidden_external_id_value(cls, val: str) -> str:
+        """Check the external_id not present in forbidden set"""
+        if val in FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS:
+            raise ValueError(
+                f"'{val}' is a reserved view External ID. Reserved External IDs are: {humanize_collection(FORBIDDEN_CONTAINER_AND_VIEW_EXTERNAL_IDS)}"
+            )
+        return val
+
+    @field_validator("properties")
+    @classmethod
+    def validate_properties_identifier(cls, val: dict[str, str]) -> dict[str, str]:
+        """Validate properties Identifier"""
+        for key in val.keys():
+            if not KEY_PATTERN.match(key):
+                raise ValueError(f"Property '{key}' does not match the required pattern: {KEY_PATTERN.pattern}")
+            if key in FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER:
+                raise ValueError(
+                    f"'{key}' is a reserved property identifier. Reserved identifiers are: {humanize_collection(FORBIDDEN_CONTAINER_AND_VIEW_PROPERTIES_IDENTIFIER)}"
+                )
+        return val
+
+    @model_serializer(mode="wrap")
+    def serialize_container(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> dict:
+        serialized_data = handler(self)
+        if self.properties:
+            serialized_data["properties"] = {
+                key: value.model_dump(**vars(info)) for key, value in self.properties.items()
+            }
+        return serialized_data

cognite_toolkit/_cdf_tk/resource_classes/workflow.py

@@ -0,0 +1,15 @@
+from cognite.client.data_classes import WorkflowUpsert
+from pydantic import Field
+
+from .base import ToolkitResource
+
+
+class WorkflowYAML(ToolkitResource):
+    _cdf_resource = WorkflowUpsert
+    external_id: str = Field(
+        max_length=255,
+        description="Identifier for a workflow. Must be unique for the project."
+        " No trailing or leading whitespace and no null characters allowed.",
+    )
+    description: str | None = Field(None, max_length=500)
+    data_set_external_id: str | None = None

cognite_toolkit/_cdf_tk/resource_classes/workflow_trigger.py

@@ -0,0 +1,115 @@
+import sys
+from types import MappingProxyType
+from typing import Any, ClassVar, cast
+
+from cognite.client.data_classes import WorkflowTrigger
+from pydantic import Field, JsonValue, ModelWrapValidatorHandler, model_serializer, model_validator
+from pydantic_core.core_schema import SerializationInfo, SerializerFunctionWrapHandler
+
+from cognite_toolkit._cdf_tk.utils import humanize_collection
+
+from .authentication import AuthenticationClientIdSecret
+from .base import BaseModelResource, ToolkitResource
+
+if sys.version_info < (3, 11):
+    from typing_extensions import Self
+else:
+    from typing import Self
+
+
+class TriggerRuleYAML(BaseModelResource):
+    _trigger_type: ClassVar[str]
+
+    @model_validator(mode="wrap")
+    @classmethod
+    def find_trigger_type(
+        cls, data: "dict[str, Any] | TriggerRuleYAML", handler: ModelWrapValidatorHandler[Self]
+    ) -> Self:
+        if isinstance(data, TriggerRuleYAML):
+            return cast(Self, data)
+        if not isinstance(data, dict):
+            raise ValueError(f"Invalid trigger rule data '{type(data)}' expected dict")
+
+        if cls is not TriggerRuleYAML:
+            # We are already in a subclass, so just validate as usual
+            return handler(data)
+        # If not we need to find the right subclass based on the triggerType field.
+        if "triggerType" not in data:
+            raise ValueError("Invalid trigger rule data missing 'triggerType' key")
+        trigger_type = data["triggerType"]
+        if trigger_type not in _TRIGGER_CLS_BY_NAME:
+            raise ValueError(
+                f"invalid trigger type '{trigger_type}'. Expected one of {humanize_collection(_TRIGGER_CLS_BY_NAME.keys(), bind_word='or')}"
+            )
+        cls_ = _TRIGGER_CLS_BY_NAME[trigger_type]
+        return cast(Self, cls_.model_validate({k: v for k, v in data.items() if k != "triggerType"}))
+
+    @model_serializer(mode="wrap", when_used="always", return_type=dict)
+    def include_trigger_type(self, handler: SerializerFunctionWrapHandler) -> dict:
+        if self._trigger_type is None:
+            raise ValueError("Trigger type is not set")
+        serialized_data = handler(self)
+        serialized_data["triggerType"] = self._trigger_type
+        return serialized_data
+
+
+class ScheduleTrigger(TriggerRuleYAML):
+    _trigger_type = "schedule"
+    cron_expression: str = Field(
+        description="A cron expression (UNIX format) specifying when the trigger should be executed. Use https://crontab.guru/ to create a cron expression. The API may adjust the exact timing of cron job executions to distribute the backend load more evenly. However, it will aim to maintain the overall frequency of executions as specified in the cron expression.",
+    )
+    timezone: str = Field(
+        "UTC",
+        description="Specifies the IANA time zone in which the cron expression is evaluated. Time zones must be valid as listed in https://docs.oracle.com/cd/E72987_01/wcs/tag-ref/MISC/TimeZones.html.",
+    )
+
+
+class DataModelingTrigger(TriggerRuleYAML):
+    _trigger_type = "dataModeling"
+    data_modeling_query: JsonValue
+    batch_size: int = Field(
+        ge=100, le=1_000, description="The maximum number of items to pass to a workflow execution."
+    )
+    batch_timeout: int = Field(
+        ge=60,
+        le=86_400,
+        description="The maximum time in seconds to wait for the batch to be filled before passing it to a workflow execution.",
+    )
+
+
+class WorkflowTriggerYAML(ToolkitResource):
+    _cdf_resource = WorkflowTrigger
+    external_id: str = Field(
+        max_length=255,
+        description="Identifier for a trigger. Must be unique for the project. "
+        "No trailing or leading whitespace and no null characters allowed.",
+    )
+    trigger_rule: TriggerRuleYAML
+    input: JsonValue | None = None
+    metadata: dict[str, str] | None = None
+    workflow_external_id: str = Field(
+        max_length=255,
+        description="Identifier for a workflow. Must be unique for the project. "
+        "No trailing or leading whitespace and no null characters allowed.",
+    )
+    workflow_version: str = Field(
+        max_length=255,
+        description="Identifier for a version. Must be unique for the workflow. No trailing or"
+        " leading whitespace and no null characters allowed.",
+    )
+    authentication: AuthenticationClientIdSecret = Field(description="Credentials required for the authentication.")
+
+    @model_serializer(mode="wrap")
+    def serialize_trigger_rules(self, handler: SerializerFunctionWrapHandler, info: SerializationInfo) -> dict:
+        # Trigger rules are serialized as empty dicts [{}, {}, ...]
+        # This issue arises because Pydantic's serialization mechanism doesn't automatically
+        # handle polymorphic serialization for subclasses of TriggerRuleYAML.
+        # To address this, we include the below to explicitly calling model dump on the trigger rule
+        serialized_data = handler(self)
+        serialized_data["triggerRule"] = self.trigger_rule.model_dump(**vars(info))
+        return serialized_data
+
+
+_TRIGGER_CLS_BY_NAME: MappingProxyType[str, type[TriggerRuleYAML]] = MappingProxyType(
+    {s._trigger_type: s for s in TriggerRuleYAML.__subclasses__()}
+)

cognite_toolkit/_cdf_tk/resource_classes/workflow_version.py

@@ -0,0 +1,233 @@
+from abc import ABC
+from typing import Annotated, Literal
+
+from cognite.client.data_classes import WorkflowVersionUpsert
+from pydantic import Field, JsonValue
+
+from .base import BaseModelResource, ToolkitResource
+
+
+class WorkflowVersionId(BaseModelResource):
+    workflow_external_id: str = Field(
+        max_length=255,
+        description="Identifier for a workflow. Must be unique for the project. No trailing or leading whitespace and no null characters allowed.",
+    )
+    version: str = Field(
+        max_length=255,
+        description="Identifier for a version. Must be unique for the workflow. No trailing or leading whitespace and no null characters allowed.",
+    )
+
+
+class CogniteFunctionRef(BaseModelResource):
+    external_id: str = Field(
+        description="The external id of the Cognite Function in the project. This can be either a function external ID or a reference like ${myTaskExternalId.output.someKey}"
+    )
+    data: str | JsonValue | None = Field(
+        None, description="Input data that will be passed to the Cognite Function. Limited to 100KB in size."
+    )
+
+
+class FunctionTaskParameters(BaseModelResource):
+    function: CogniteFunctionRef
+    is_async_complete: bool = Field(
+        False, description="Defines if the execution of the task should be completed asynchronously."
+    )
+
+
+class TransformationRef(BaseModelResource):
+    external_id: str = Field(
+        description="The external id of the Transformation in the project. This can be either a transformation external ID or a reference like ${myTaskExternalId.output.someKey}"
+    )
+    concurrency_policy: Literal["fail", "waitForCurrent", "restartAfterCurrent"] = Field(
+        "fail",
+        description="""Determines the behavior of the task if the Transformation is already running.
+
+fail: The task fails if another instance of the Transformation is currently running.
+waitForCurrent: The task will pause and wait for the already running Transformation to complete. Once completed, the task is completed. This mode is useful for preventing redundant Transformation runs.
+restartAfterCurrent: The task waits for the ongoing Transformation to finish. After completion, the task restarts the Transformation. This mode ensures that the most recent data can be used by following tasks.""",
+    )
+    use_transformation_credentials: bool = Field(
+        False,
+        description="If set to true, the transformation will run using the client credentials configured on the transformation. If set to false, the transformation will run using the client credentials used to trigger the workflow.",
+    )
+
+
+class TransformationTaskParameters(BaseModelResource):
+    transformation: TransformationRef
+
+
+class CDFRequest(BaseModelResource):
+    resource_path: str = Field(
+        description="The path of the request. The path should be prefixed by {cluster}.cognitedata.com/api/v1/project/{project} based on the relevant cluster and project. It can also contain references like ${myTaskExternalId.output.someKey}"
+    )
+    method: Literal["POST", "GET", "PUT"] | str = Field(
+        description="The HTTP method of the request. It can also be a reference like ${myTaskExternalId.output.someKey}"
+    )
+    query_parameters: dict[str, JsonValue] | str | None = Field(
+        None,
+        description="The query parameters of the request. It can also be a reference like ${myTaskExternalId.output.someKey}",
+    )
+    body: JsonValue | str | None = Field(
+        None, description="The body of the request. It can also be a reference like ${myTaskExternalId.output.someKey}"
+    )
+    request_timeout_in_millis: float | str | None = Field(
+        None,
+        description="The timeout for the request in milliseconds. It can also be a reference like ${myTaskExternalId.output.someKey}",
+    )
+    cdf_version_header: Literal["alpha", "beta"] | str | None = Field(
+        None, description="The Cognite Data Fusion version header to use for the request."
+    )
+
+
+class CDFTaskParameters(BaseModelResource):
+    cdf_request: CDFRequest
+
+
+class DynamicRef(BaseModelResource):
+    tasks: str = Field(
+        description="A Reference is an expression that allows dynamically injecting input to a task during execution. References can be used to reference the input of the Workflow, the output of a previous task in the Workflow, or the input of a previous task in the Workflow. Note that the injected value must be valid in the context of the property it is injected into. Example Task reference: ${myTaskExternalId.output.someKey} Example Workflow input reference: ${workflow.input.myKey}"
+    )
+
+
+class DynamicTaskParameters(BaseModelResource):
+    dynamic: DynamicRef = Field(description="Reference to another task to use as the definition for this task.")
+
+
+class SubworkflowRef(BaseModelResource):
+    tasks: "WorkflowVersionId | list[Task]" = Field(
+        description="Reference to the subworkflow to execute. This can be either a reference to an existing workflow version or an inline definition of tasks."
+    )
+
+
+class SubworkflowTaskParameters(BaseModelResource):
+    subworkflow: SubworkflowRef = Field(description="Reference to the subworkflow to execute.")
+
+
+class SimulatorInputUnit(BaseModelResource):
+    name: str = Field(description="Name of the unit.")
+
+
+class SimulatorInput(BaseModelResource):
+    reference_id: str = Field(description="Reference id of the value to override.")
+    value: str | int | float | list[str] | list[int] | list[float] = Field(
+        description="Override the value used for a simulation run."
+    )
+    unit: SimulatorInputUnit | None = Field(None, description="Override the unit of the value")
+
+
+class SimulationRef(BaseModelResource):
+    routine_external_id: str = Field(description="The external id of the routine to be executed.")
+    run_time: int | None = Field(
+        None,
+        description="Run time in milliseconds. Reference timestamp used for data pre-processing and data sampling.",
+    )
+    inputs: list[SimulatorInput] | None = Field(
+        None, description="List of inputs to be provided to the simulation.", max_length=200
+    )
+
+
+class SimulationTaskParameters(BaseModelResource):
+    simulation: SimulationRef = Field(description="Reference to the simulation to execute.")
+
+
+class TaskId(BaseModelResource):
+    external_id: str = Field(
+        max_length=255, description="The external ID provided by the client. Must be unique for the resource type."
+    )
+
+
+class TaskDefinition(BaseModelResource, ABC):
+    external_id: str = Field(
+        max_length=255,
+        description="Identifier for the task. Must be unique within the version. No trailing or leading whitespace and no null characters allowed.",
+    )
+    type: str
+    name: str | None = Field(
+        default=None,
+        max_length=255,
+        description="Readable name meant for use in UIs",
+    )
+    description: str | None = Field(
+        default=None,
+        max_length=500,
+        description="Description of the intention of the task",
+    )
+    retries: int = Field(
+        3,
+        ge=0,
+        le=10,
+        description="Number of times to retry the task if it fails. If set to 0, the task will not be retried. The behavior for timeouts and retries is defined by the onFailure parameter, refer to it for more information.",
+    )
+    timeout: int = Field(
+        3600,
+        ge=60,
+        le=86400,
+        description="TTimeout in seconds. After this time, the task will be marked as TIMED_OUT. By default, the task won't be retried upon timeout. Use the onFailure parameter to change this behavior.",
+    )
+    on_failure: Literal["abortWorkflow", "skipTask"] = Field(
+        "abortWorkflow",
+        description="Defines the behavior when a task fails. If set to abortWorkflow, the entire workflow will be marked as FAILED when the task fails. If set to skipTask, the task will be marked as FAILED, but the workflow will continue executing subsequent tasks that are not dependent on the failed task.",
+    )
+    depends_on: list[TaskId] | None = Field(
+        None,
+        description="The tasks that must be completed before this task can be executed.",
+        max_length=100,
+    )
+
+
+class FunctionTask(TaskDefinition):
+    type: Literal["function"] = "function"
+    parameters: FunctionTaskParameters
+
+
+class TransformationTask(TaskDefinition):
+    type: Literal["transformation"] = "transformation"
+    parameters: TransformationTaskParameters
+
+
+class CDFTask(TaskDefinition):
+    type: Literal["cdfRequest"] = "cdfRequest"
+    parameters: CDFTaskParameters
+
+
+class DynamicTask(TaskDefinition):
+    type: Literal["dynamic"] = "dynamic"
+    parameters: DynamicTaskParameters
+
+
+class SubworkflowTask(TaskDefinition):
+    type: Literal["subworkflow"] = "subworkflow"
+    parameters: SubworkflowTaskParameters
+
+
+class SimulationTask(TaskDefinition):
+    type: Literal["simulation"] = "simulation"
+    parameters: SimulationTaskParameters
+
+
+Task = Annotated[
+    FunctionTask | TransformationTask | CDFTask | DynamicTask | SubworkflowTask | SimulationTask,
+    Field(discriminator="type"),
+]
+
+
+class WorkflowDefinition(BaseModelResource):
+    description: str | None = Field(
+        default=None,
+        max_length=500,
+        description="The description of the workflow version.",
+    )
+    tasks: list[Task]
+
+
+class WorkflowVersionYAML(ToolkitResource):
+    _cdf_resource = WorkflowVersionUpsert
+    workflow_external_id: str = Field(
+        max_length=255,
+        description="Identifier for a workflow. Must be unique for the project. No trailing or leading whitespace and no null characters allowed.",
+    )
+    version: str = Field(
+        max_length=255,
+        description="Identifier for a version. Must be unique for the workflow. No trailing or leading whitespace and no null characters allowed.",
+    )
+    workflow_definition: WorkflowDefinition