> ## Documentation Index
> Fetch the complete documentation index at: https://docs.domino.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Indicates a :ref:`ref_flyteidl.event.TaskExecutionEvent` has occurred

> Create a task execution event recording a phase transition.



## OpenAPI

````yaml /api-specs/cloud/flyte-native-api.yaml post /api/v1/events/tasks
openapi: 3.0.0
info:
  title: flyteidl/service/admin.proto
  version: version not set
servers:
  - url: https://mycluster.domino.tech
    description: >-
      Replace 'mycluster.domino.tech' with your Domino cluster hostname. For
      Domino Cloud customers, that is <your-subdomain>.domino.tech (e.g.,
      acme.domino.tech). For self-hosted deployments, it is the hostname you
      reach the Domino UI at.
security: []
tags:
  - name: AdminService
paths:
  /api/v1/events/tasks:
    post:
      tags:
        - AdminService
      summary: Indicates a :ref:`ref_flyteidl.event.TaskExecutionEvent` has occurred
      description: Create a task execution event recording a phase transition.
      operationId: AdminService_CreateTaskEvent
      requestBody:
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/adminTaskExecutionEventRequest'
        description: >-
          Request to send a notification that a task execution event has
          occurred.
        required: true
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/adminTaskExecutionEventResponse'
        default:
          description: An unexpected error response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/googlerpcStatus'
components:
  schemas:
    adminTaskExecutionEventRequest:
      type: object
      properties:
        request_id:
          type: string
          title: Unique ID for this request that can be traced between services
        event:
          $ref: '#/components/schemas/eventTaskExecutionEvent'
      description: Request to send a notification that a task execution event has occurred.
    adminTaskExecutionEventResponse:
      type: object
      description: Purposefully empty, may be populated in the future.
    googlerpcStatus:
      type: object
      properties:
        code:
          type: integer
          format: int32
        message:
          type: string
        details:
          type: array
          items:
            $ref: '#/components/schemas/protobufAny'
    eventTaskExecutionEvent:
      type: object
      properties:
        task_id:
          $ref: '#/components/schemas/coreIdentifier'
        parent_node_execution_id:
          $ref: '#/components/schemas/coreNodeExecutionIdentifier'
        retry_attempt:
          type: integer
          format: int64
          title: retry attempt number for this task, ie., 2 for the second attempt
        phase:
          $ref: '#/components/schemas/coreTaskExecutionPhase'
        producer_id:
          type: string
          title: id of the process that sent this event, mainly for trace debugging
        logs:
          type: array
          items:
            $ref: '#/components/schemas/coreTaskLog'
          title: log information for the task execution
        occurred_at:
          type: string
          format: date-time
          description: >-
            This timestamp represents when the original event occurred, it is
            generated

            by the executor of the task.
        input_uri:
          type: string
          description: |-
            URI of the input file, it encodes all the information
            including Cloud source provider. ie., s3://...
        input_data:
          $ref: '#/components/schemas/coreLiteralMap'
        output_uri:
          type: string
          description: >-
            URI to the output of the execution, it will be in a format that
            encodes all the information

            including Cloud source provider. ie., s3://...
        error:
          $ref: '#/components/schemas/coreExecutionError'
        output_data:
          $ref: '#/components/schemas/coreLiteralMap'
        custom_info:
          type: object
          description: >-
            Custom data that the task plugin sends back. This is extensible to
            allow various plugins in the system.
        phase_version:
          type: integer
          format: int64
          description: >-
            Some phases, like RUNNING, can send multiple events with changed
            metadata (new logs, additional custom_info, etc)

            that should be recorded regardless of the lack of phase change.

            The version field should be incremented when metadata changes across
            the duration of an individual phase.
        reason:
          type: string
          description: |-
            An optional explanation for the phase transition.
            Deprecated: Use reasons instead.
        reasons:
          type: array
          items:
            $ref: '#/components/schemas/eventEventReason'
          description: An optional list of explanations for the phase transition.
        task_type:
          type: string
          description: >-
            A predefined yet extensible Task type identifier. If the task
            definition is already registered in flyte admin

            this type will be identical, but not all task executions necessarily
            use pre-registered definitions and this

            type is useful to render the task in the UI, filter task executions,
            etc.
        metadata:
          $ref: '#/components/schemas/flyteidleventTaskExecutionMetadata'
        event_version:
          type: integer
          format: int32
          description: >-
            The event version is used to indicate versioned changes in how data
            is reported using this

            proto message. For example, event_verison > 0 means that maps tasks
            report logs using the

            TaskExecutionMetadata ExternalResourceInfo fields for each subtask
            rather than the TaskLog

            in this message.
        reported_at:
          type: string
          format: date-time
          description: >-
            This timestamp represents the instant when the event was reported by
            the executing framework. For example, a k8s

            pod task may be marked completed at (ie. `occurred_at`) the instant
            the container running user code completes,

            but this event will not be reported until the pod is marked as
            completed. Extracting both of these timestamps

            facilitates a more accurate portrayal of the evaluation time-series.
        log_context:
          $ref: '#/components/schemas/coreLogContext'
      description: >-
        Plugin specific execution event information. For tasks like Python,
        Hive, Spark, DynamicJob.
    protobufAny:
      type: object
      properties:
        '@type':
          type: string
          description: >-
            A URL/resource name that uniquely identifies the type of the
            serialized

            protocol buffer message. This string must contain at least

            one "/" character. The last segment of the URL's path must represent

            the fully qualified name of the type (as in

            `path/google.protobuf.Duration`). The name should be in a canonical
            form

            (e.g., leading "." is not accepted).


            In practice, teams usually precompile into the binary all types that
            they

            expect it to use in the context of Any. However, for URLs which use
            the

            scheme `http`, `https`, or no scheme, one can optionally set up a
            type

            server that maps type URLs to message definitions as follows:


            * If no scheme is provided, `https` is assumed.

            * An HTTP GET on the URL must yield a [google.protobuf.Type][]
              value in binary format, or produce an error.
            * Applications are allowed to cache lookup results based on the
              URL, or have them precompiled into a binary to avoid any
              lookup. Therefore, binary compatibility needs to be preserved
              on changes to types. (Use versioned type names to manage
              breaking changes.)

            Note: this functionality is not currently available in the official

            protobuf release, and it is not used for type URLs beginning with

            type.googleapis.com. As of May 2023, there are no widely used type
            server

            implementations and no plans to implement one.


            Schemes other than `http`, `https` (or the empty scheme) might be

            used with implementation specific semantics.
      additionalProperties: {}
      description: >-
        `Any` contains an arbitrary serialized protocol buffer message along
        with a

        URL that describes the type of the serialized message.


        Protobuf library provides support to pack/unpack Any values in the form

        of utility functions or additional generated methods of the Any type.


        Example 1: Pack and unpack a message in C++.

            Foo foo = ...;
            Any any;
            any.PackFrom(foo);
            ...
            if (any.UnpackTo(&foo)) {
              ...
            }

        Example 2: Pack and unpack a message in Java.

            Foo foo = ...;
            Any any = Any.pack(foo);
            ...
            if (any.is(Foo.class)) {
              foo = any.unpack(Foo.class);
            }
            // or ...
            if (any.isSameTypeAs(Foo.getDefaultInstance())) {
              foo = any.unpack(Foo.getDefaultInstance());
            }

         Example 3: Pack and unpack a message in Python.

            foo = Foo(...)
            any = Any()
            any.Pack(foo)
            ...
            if any.Is(Foo.DESCRIPTOR):
              any.Unpack(foo)
              ...

         Example 4: Pack and unpack a message in Go

             foo := &pb.Foo{...}
             any, err := anypb.New(foo)
             if err != nil {
               ...
             }
             ...
             foo := &pb.Foo{}
             if err := any.UnmarshalTo(foo); err != nil {
               ...
             }

        The pack methods provided by protobuf library will by default use

        'type.googleapis.com/full.type.name' as the type URL and the unpack

        methods only use the fully qualified type name after the last '/'

        in the type URL, for example "foo.bar.com/x/y.z" will yield type

        name "y.z".


        JSON

        ====

        The JSON representation of an `Any` value uses the regular

        representation of the deserialized, embedded message, with an

        additional field `@type` which contains the type URL. Example:

            package google.profile;
            message Person {
              string first_name = 1;
              string last_name = 2;
            }

            {
              "@type": "type.googleapis.com/google.profile.Person",
              "firstName": <string>,
              "lastName": <string>
            }

        If the embedded message type is well-known and has a custom JSON

        representation, that representation will be embedded adding a field

        `value` which holds the custom JSON in addition to the `@type`

        field. Example (for message [google.protobuf.Duration][]):

            {
              "@type": "type.googleapis.com/google.protobuf.Duration",
              "value": "1.212s"
            }
    coreIdentifier:
      type: object
      properties:
        resource_type:
          $ref: '#/components/schemas/coreResourceType'
        project:
          type: string
          description: Name of the project the resource belongs to.
        domain:
          type: string
          description: |-
            Name of the domain the resource belongs to.
            A domain can be considered as a subset within a specific project.
        name:
          type: string
          description: User provided value for the resource.
        version:
          type: string
          description: Specific version of the resource.
        org:
          type: string
          description: Optional, org key applied to the resource.
      description: Encapsulation of fields that uniquely identifies a Flyte resource.
    coreNodeExecutionIdentifier:
      type: object
      properties:
        node_id:
          type: string
        execution_id:
          $ref: '#/components/schemas/coreWorkflowExecutionIdentifier'
      description: Encapsulation of fields that identify a Flyte node execution entity.
    coreTaskExecutionPhase:
      type: string
      enum:
        - UNDEFINED
        - QUEUED
        - RUNNING
        - SUCCEEDED
        - ABORTED
        - FAILED
        - INITIALIZING
        - WAITING_FOR_RESOURCES
        - RETRYABLE_FAILED
      default: UNDEFINED
      title: >-
        - INITIALIZING: To indicate cases where task is initializing, like:
        ErrImagePull, ContainerCreating, PodInitializing
         - WAITING_FOR_RESOURCES: To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded
    coreTaskLog:
      type: object
      properties:
        uri:
          type: string
        name:
          type: string
        message_format:
          $ref: '#/components/schemas/TaskLogMessageFormat'
        ttl:
          type: string
        ShowWhilePending:
          type: boolean
        HideOnceFinished:
          type: boolean
      title: >-
        Log information for the task that is specific to a log sink

        When our log story is flushed out, we may have more metadata here like
        log link expiry
    coreLiteralMap:
      type: object
      properties:
        literals:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/coreLiteral'
      description: >-
        A map of literals. This is a workaround since oneofs in proto messages
        cannot contain a repeated field.
    coreExecutionError:
      type: object
      properties:
        code:
          type: string
          title: |-
            Error code indicates a grouping of a type of error.
            More Info: <Link>
        message:
          type: string
          description: Detailed description of the error - including stack trace.
        error_uri:
          type: string
          title: Full error contents accessible via a URI
        kind:
          $ref: '#/components/schemas/ExecutionErrorErrorKind'
        timestamp:
          type: string
          format: date-time
          title: Timestamp of the error
        worker:
          type: string
          title: Worker that generated the error
      description: Represents the error message from the execution.
    eventEventReason:
      type: object
      properties:
        reason:
          type: string
          title: An explanation for this event
        occurred_at:
          type: string
          format: date-time
          title: The time this reason occurred
    flyteidleventTaskExecutionMetadata:
      type: object
      properties:
        generated_name:
          type: string
          description: Unique, generated name for this task execution used by the backend.
        external_resources:
          type: array
          items:
            $ref: '#/components/schemas/eventExternalResourceInfo'
          description: >-
            Additional data on external resources on other back-ends or
            platforms (e.g. Hive, Qubole, etc) launched by this task execution.
        resource_pool_info:
          type: array
          items:
            $ref: '#/components/schemas/eventResourcePoolInfo'
          description: >-
            Includes additional data on concurrent resource management used
            during execution..

            This is a repeated field because a plugin can request multiple
            resource allocations during execution.
        plugin_identifier:
          type: string
          description: The identifier of the plugin used to execute this task.
        instance_class:
          $ref: '#/components/schemas/TaskExecutionMetadataInstanceClass'
      description: >-
        Holds metadata around how a task was executed.

        As a task transitions across event phases during execution some
        attributes, such its generated name, generated external resources,

        and more may grow in size but not change necessarily based on the phase
        transition that sparked the event update.

        Metadata is a container for these attributes across the task execution
        lifecycle.
    coreLogContext:
      type: object
      properties:
        pods:
          type: array
          items:
            $ref: '#/components/schemas/corePodLogContext'
        primary_pod_name:
          type: string
      title: Contains metadata required to identify logs produces by a set of pods
    coreResourceType:
      type: string
      enum:
        - UNSPECIFIED
        - TASK
        - WORKFLOW
        - LAUNCH_PLAN
        - DATASET
      default: UNSPECIFIED
      description: >-
        Indicates a resource type within Flyte.

         - DATASET: A dataset represents an entity modeled in Flyte DataCatalog. A Dataset is also a versioned entity and can be a compilation of multiple individual objects.
        Eventually all Catalog objects should be modeled similar to Flyte
        Objects. The Dataset entities makes it possible for the UI  and CLI to
        act on the objects 

        in a similar manner to other Flyte objects
    coreWorkflowExecutionIdentifier:
      type: object
      properties:
        project:
          type: string
          description: Name of the project the resource belongs to.
        domain:
          type: string
          description: |-
            Name of the domain the resource belongs to.
            A domain can be considered as a subset within a specific project.
        name:
          type: string
          description: User or system provided value for the resource.
        org:
          type: string
          description: Optional, org key applied to the resource.
      title: >-
        Encapsulation of fields that uniquely identifies a Flyte workflow
        execution
    TaskLogMessageFormat:
      type: string
      enum:
        - UNKNOWN
        - CSV
        - JSON
      default: UNKNOWN
    coreLiteral:
      type: object
      properties:
        scalar:
          $ref: '#/components/schemas/coreScalar'
        collection:
          $ref: '#/components/schemas/coreLiteralCollection'
        map:
          $ref: '#/components/schemas/coreLiteralMap'
        offloaded_metadata:
          $ref: '#/components/schemas/coreLiteralOffloadedMetadata'
        hash:
          type: string
          title: >-
            A hash representing this literal.

            This is used for caching purposes. For more details refer to RFC
            1893

            (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md)
        metadata:
          type: object
          additionalProperties:
            type: string
          description: Additional metadata for literals.
      description: >-
        A simple value. This supports any level of nesting (e.g. array of array
        of array of Blobs) as well as simple primitives.
    ExecutionErrorErrorKind:
      type: string
      enum:
        - UNKNOWN
        - USER
        - SYSTEM
      default: UNKNOWN
      title: 'Error type: System or User'
    eventExternalResourceInfo:
      type: object
      properties:
        external_id:
          type: string
          description: >-
            Identifier for an external resource created by this task execution,
            for example Qubole query ID or presto query ids.
        index:
          type: integer
          format: int64
          description: >-
            A unique index for the external resource with respect to all
            external resources for this task. Although the

            identifier may change between task reporting events or retries, this
            will remain the same to enable aggregating

            information from multiple reports.
        retry_attempt:
          type: integer
          format: int64
          title: >-
            Retry attempt number for this external resource, ie., 2 for the
            second attempt
        phase:
          $ref: '#/components/schemas/coreTaskExecutionPhase'
        cache_status:
          $ref: '#/components/schemas/coreCatalogCacheStatus'
        logs:
          type: array
          items:
            $ref: '#/components/schemas/coreTaskLog'
          title: log information for the external resource execution
        workflow_node_metadata:
          $ref: '#/components/schemas/flyteidleventWorkflowNodeMetadata'
        custom_info:
          type: object
          title: Extensible field for custom, plugin-specific info
        log_context:
          $ref: '#/components/schemas/coreLogContext'
      description: >-
        This message contains metadata about external resources produced or used
        by a specific task execution.
    eventResourcePoolInfo:
      type: object
      properties:
        allocation_token:
          type: string
          description: >-
            Unique resource ID used to identify this execution when allocating a
            token.
        namespace:
          type: string
          description: >-
            Namespace under which this task execution requested an allocation
            token.
      description: >-
        This message holds task execution metadata specific to resource
        allocation used to manage concurrent

        executions for a project namespace.
    TaskExecutionMetadataInstanceClass:
      type: string
      enum:
        - DEFAULT
        - INTERRUPTIBLE
      default: DEFAULT
      description: >-
        Includes the broad category of machine used for this specific task
        execution.

         - DEFAULT: The default instance class configured for the flyte application platform.
         - INTERRUPTIBLE: The instance class configured for interruptible tasks.
    corePodLogContext:
      type: object
      properties:
        namespace:
          type: string
        pod_name:
          type: string
        containers:
          type: array
          items:
            $ref: '#/components/schemas/coreContainerContext'
        primary_container_name:
          type: string
        init_containers:
          type: array
          items:
            $ref: '#/components/schemas/coreContainerContext'
      title: Contains metadata required to identify logs produces by a single pod
    coreScalar:
      type: object
      properties:
        primitive:
          $ref: '#/components/schemas/corePrimitive'
        blob:
          $ref: '#/components/schemas/coreBlob'
        binary:
          $ref: '#/components/schemas/coreBinary'
        schema:
          $ref: '#/components/schemas/flyteidlcoreSchema'
        none_type:
          $ref: '#/components/schemas/coreVoid'
        error:
          $ref: '#/components/schemas/coreError'
        generic:
          type: object
        structured_dataset:
          $ref: '#/components/schemas/coreStructuredDataset'
        union:
          $ref: '#/components/schemas/coreUnion'
    coreLiteralCollection:
      type: object
      properties:
        literals:
          type: array
          items:
            $ref: '#/components/schemas/coreLiteral'
      description: >-
        A collection of literals. This is a workaround since oneofs in proto
        messages cannot contain a repeated field.
    coreLiteralOffloadedMetadata:
      type: object
      properties:
        uri:
          type: string
          description: The location of the offloaded core.Literal.
        size_bytes:
          type: string
          format: uint64
          description: The size of the offloaded data.
        inferred_type:
          $ref: '#/components/schemas/coreLiteralType'
      description: A message that contains the metadata of the offloaded data.
    coreCatalogCacheStatus:
      type: string
      enum:
        - CACHE_DISABLED
        - CACHE_MISS
        - CACHE_HIT
        - CACHE_POPULATED
        - CACHE_LOOKUP_FAILURE
        - CACHE_PUT_FAILURE
        - CACHE_SKIPPED
        - CACHE_EVICTED
      default: CACHE_DISABLED
      description: |-
        - CACHE_DISABLED: Used to indicate that caching was disabled
         - CACHE_MISS: Used to indicate that the cache lookup resulted in no matches
         - CACHE_HIT: used to indicate that the associated artifact was a result of a previous execution
         - CACHE_POPULATED: used to indicate that the resultant artifact was added to the cache
         - CACHE_LOOKUP_FAILURE: Used to indicate that cache lookup failed because of an error
         - CACHE_PUT_FAILURE: Used to indicate that cache lookup failed because of an error
         - CACHE_SKIPPED: Used to indicate the cache lookup was skipped
         - CACHE_EVICTED: Used to indicate that the cache was evicted
      title: >-
        Indicates the status of CatalogCaching. The reason why this is not
        embedded in TaskNodeMetadata is, that we may use for other types of
        nodes as well in the future
    flyteidleventWorkflowNodeMetadata:
      type: object
      properties:
        execution_id:
          $ref: '#/components/schemas/coreWorkflowExecutionIdentifier'
      title: >-
        For Workflow Nodes we need to send information about the workflow that's
        launched
    coreContainerContext:
      type: object
      properties:
        container_name:
          type: string
        process:
          $ref: '#/components/schemas/ContainerContextProcessContext'
      title: >-
        Contains metadata required to identify logs produces by a single
        container
    corePrimitive:
      type: object
      properties:
        integer:
          type: string
          format: int64
        float_value:
          type: number
          format: double
        string_value:
          type: string
        boolean:
          type: boolean
        datetime:
          type: string
          format: date-time
        duration:
          type: string
      title: Primitive Types
    coreBlob:
      type: object
      properties:
        metadata:
          $ref: '#/components/schemas/coreBlobMetadata'
        uri:
          type: string
      description: >-
        Refers to an offloaded set of files. It encapsulates the type of the
        store and a unique uri for where the data is.

        There are no restrictions on how the uri is formatted since it will
        depend on how to interact with the store.
    coreBinary:
      type: object
      properties:
        value:
          type: string
          format: byte
          description: >-
            Serialized data (MessagePack) for supported types like Dataclass,
            Pydantic BaseModel, and untyped dict.
        tag:
          type: string
          description: >-
            The serialization format identifier (e.g., MessagePack). Consumers
            must define unique tags and validate them before deserialization.
      description: >-
        A simple byte array with a tag to help different parts of the system
        communicate about what is in the byte array.

        It's strongly advisable that consumers of this type define a unique tag
        and validate the tag before parsing the data.
    flyteidlcoreSchema:
      type: object
      properties:
        uri:
          type: string
        type:
          $ref: '#/components/schemas/coreSchemaType'
      description: >-
        A strongly typed schema that defines the interface of data retrieved
        from the underlying storage medium.
    coreVoid:
      type: object
      description: >-
        Used to denote a nil/null/None assignment to a scalar value. The
        underlying LiteralType for Void is intentionally

        undefined since it can be assigned to a scalar of any LiteralType.
    coreError:
      type: object
      properties:
        failed_node_id:
          type: string
          description: The node id that threw the error.
        message:
          type: string
          description: Error message thrown.
      description: Represents an error thrown from a node.
    coreStructuredDataset:
      type: object
      properties:
        uri:
          type: string
          title: >-
            String location uniquely identifying where the data is.

            Should start with the storage location (e.g. s3://, gs://, bq://,
            etc.)
        metadata:
          $ref: '#/components/schemas/coreStructuredDatasetMetadata'
    coreUnion:
      type: object
      properties:
        value:
          $ref: '#/components/schemas/coreLiteral'
        type:
          $ref: '#/components/schemas/coreLiteralType'
      description: >-
        The runtime representation of a tagged union value. See `UnionType` for
        more details.
    coreLiteralType:
      type: object
      properties:
        simple:
          $ref: '#/components/schemas/coreSimpleType'
        schema:
          $ref: '#/components/schemas/coreSchemaType'
        collection_type:
          $ref: '#/components/schemas/coreLiteralType'
        map_value_type:
          $ref: '#/components/schemas/coreLiteralType'
        blob:
          $ref: '#/components/schemas/coreBlobType'
        enum_type:
          $ref: '#/components/schemas/flyteidlcoreEnumType'
        structured_dataset_type:
          $ref: '#/components/schemas/coreStructuredDatasetType'
        union_type:
          $ref: '#/components/schemas/coreUnionType'
        metadata:
          type: object
          description: >-
            This field contains type metadata that is descriptive of the type,
            but is NOT considered in type-checking.  This might be used by

            consumers to identify special behavior or display extended
            information for the type.
        annotation:
          $ref: '#/components/schemas/coreTypeAnnotation'
        structure:
          $ref: '#/components/schemas/coreTypeStructure'
      description: Defines a strong type to allow type checking between interfaces.
    ContainerContextProcessContext:
      type: object
      properties:
        container_start_time:
          type: string
          format: date-time
        container_end_time:
          type: string
          format: date-time
      title: >-
        Contains metadata required to identify logs produces by a single
        light-weight process that was run inside a container
    coreBlobMetadata:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/coreBlobType'
    coreSchemaType:
      type: object
      properties:
        columns:
          type: array
          items:
            $ref: '#/components/schemas/SchemaTypeSchemaColumn'
          description: A list of ordered columns this schema comprises of.
      description: >-
        Defines schema columns and types to strongly type-validate schemas
        interoperability.
    coreStructuredDatasetMetadata:
      type: object
      properties:
        structured_dataset_type:
          $ref: '#/components/schemas/coreStructuredDatasetType'
    coreSimpleType:
      type: string
      enum:
        - NONE
        - INTEGER
        - FLOAT
        - STRING
        - BOOLEAN
        - DATETIME
        - DURATION
        - BINARY
        - ERROR
        - STRUCT
      default: NONE
      description: Define a set of simple types.
    coreBlobType:
      type: object
      properties:
        format:
          type: string
          title: |-
            Format can be a free form string understood by SDK/UI etc like
            csv, parquet etc
        dimensionality:
          $ref: '#/components/schemas/BlobTypeBlobDimensionality'
      title: Defines type behavior for blob objects
    flyteidlcoreEnumType:
      type: object
      properties:
        values:
          type: array
          items:
            type: string
          description: Predefined set of enum values.
      description: >-
        Enables declaring enum types, with predefined string values

        For len(values) > 0, the first value in the ordered list is regarded as
        the default value. If you wish

        To provide no defaults, make the first value as undefined.
    coreStructuredDatasetType:
      type: object
      properties:
        columns:
          type: array
          items:
            $ref: '#/components/schemas/StructuredDatasetTypeDatasetColumn'
          description: A list of ordered columns this schema comprises of.
        format:
          type: string
          description: >-
            This is the storage format, the format of the bits at rest

            parquet, feather, csv, etc.

            For two types to be compatible, the format will need to be an exact
            match.
        external_schema_type:
          type: string
          description: >-
            This is a string representing the type that the bytes in
            external_schema_bytes are formatted in.

            This is an optional field that will not be used for type checking.
        external_schema_bytes:
          type: string
          format: byte
          description: |-
            The serialized bytes of a third-party schema library like Arrow.
            This is an optional field that will not be used for type checking.
    coreUnionType:
      type: object
      properties:
        variants:
          type: array
          items:
            $ref: '#/components/schemas/coreLiteralType'
          description: Predefined set of variants in union.
      description: >-
        Defines a tagged union type, also known as a variant (and formally as
        the sum type).


        A sum type S is defined by a sequence of types (A, B, C, ...), each
        tagged by a string tag

        A value of type S is constructed from a value of any of the variant
        types. The specific choice of type is recorded by

        storing the varaint's tag with the literal value and can be examined in
        runtime.


        Type S is typically written as

        S := Apple A | Banana B | Cantaloupe C | ...


        Notably, a nullable (optional) type is a sum type between some type X
        and the singleton type representing a null-value:

        Optional X := X | Null


        See also: https://en.wikipedia.org/wiki/Tagged_union
    coreTypeAnnotation:
      type: object
      properties:
        annotations:
          type: object
          description: A arbitrary JSON payload to describe a type.
      description: >-
        TypeAnnotation encapsulates registration time information about a type.
        This can be used for various control-plane operations. TypeAnnotation
        will not be available at runtime when a task runs.
    coreTypeStructure:
      type: object
      properties:
        tag:
          type: string
          title: Must exactly match for types to be castable
        dataclass_type:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/coreLiteralType'
          title: >-
            dataclass_type only exists for dataclasses.

            This is used to resolve the type of the fields of dataclass

            The key is the field name, and the value is the literal type of the
            field

            e.g. For dataclass Foo, with fields a, and a is a string

            Foo.a will be resolved as a literal type of string from
            dataclass_type
      description: |-
        Hints to improve type matching
        e.g. allows distinguishing output from custom type transformers
        even if the underlying IDL serialization matches.
    SchemaTypeSchemaColumn:
      type: object
      properties:
        name:
          type: string
          title: A unique name -within the schema type- for the column
        type:
          $ref: '#/components/schemas/SchemaColumnSchemaColumnType'
    BlobTypeBlobDimensionality:
      type: string
      enum:
        - SINGLE
        - MULTIPART
      default: SINGLE
    StructuredDatasetTypeDatasetColumn:
      type: object
      properties:
        name:
          type: string
          description: A unique name within the schema type for the column.
        literal_type:
          $ref: '#/components/schemas/coreLiteralType'
    SchemaColumnSchemaColumnType:
      type: string
      enum:
        - INTEGER
        - FLOAT
        - STRING
        - BOOLEAN
        - DATETIME
        - DURATION
      default: INTEGER

````