{
  "components": {
    "schemas": {
      "AdminServiceDeleteProjectAttributesBody": {
        "properties": {
          "org": {
            "description": "Optional, org key applied to the project.",
            "type": "string"
          },
          "resource_type": {
            "$ref": "#/components/schemas/adminMatchableResource"
          }
        },
        "title": "Request to delete a set matchable project level attribute override.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "AdminServiceDeleteProjectDomainAttributesBody": {
        "properties": {
          "org": {
            "description": "Optional, org key applied to the attributes.",
            "type": "string"
          },
          "resource_type": {
            "$ref": "#/components/schemas/adminMatchableResource"
          }
        },
        "title": "Request to delete a set matchable project domain attribute override.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "AdminServiceDeleteWorkflowAttributesBody": {
        "properties": {
          "org": {
            "description": "Optional, org key applied to the attributes.",
            "type": "string"
          },
          "resource_type": {
            "$ref": "#/components/schemas/adminMatchableResource"
          }
        },
        "title": "Request to delete a set matchable workflow attribute override.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "AdminServiceTerminateExecutionBody": {
        "description": "Request to terminate an in-progress execution.  This action is irreversible.\nIf an execution is already terminated, this request will simply be a no-op.\nThis request will fail if it references a non-existent execution.\nIf the request succeeds the phase \"ABORTED\" will be recorded for the termination\nwith the optional cause added to the output_result.",
        "properties": {
          "cause": {
            "description": "Optional reason for aborting.",
            "type": "string"
          },
          "id": {
            "description": "Uniquely identifies the individual workflow execution to be terminated.",
            "properties": {
              "org": {
                "description": "Optional, org key applied to the resource.",
                "type": "string"
              }
            },
            "title": "Uniquely identifies the individual workflow execution to be terminated.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "AdminServiceUpdateExecutionBody": {
        "properties": {
          "id": {
            "properties": {
              "org": {
                "description": "Optional, org key applied to the resource.",
                "type": "string"
              }
            },
            "title": "Identifier of the execution to update",
            "type": "object"
          },
          "state": {
            "$ref": "#/components/schemas/adminExecutionState"
          }
        },
        "type": "object"
      },
      "AdminServiceUpdateLaunchPlanBody": {
        "properties": {
          "id": {
            "description": "Identifier of launch plan for which to change state.\n+required.",
            "properties": {
              "org": {
                "description": "Optional, org key applied to the resource.",
                "type": "string"
              },
              "resource_type": {
                "$ref": "#/components/schemas/coreResourceType"
              }
            },
            "title": "Identifier of launch plan for which to change state.\n+required.",
            "type": "object"
          },
          "state": {
            "$ref": "#/components/schemas/adminLaunchPlanState"
          }
        },
        "title": "Request to set the referenced launch plan state to the configured value.\nSee LaunchPlan for more details",
        "type": "object"
      },
      "AdminServiceUpdateNamedEntityBody": {
        "description": "Request to set the referenced named entity state to the configured value.",
        "properties": {
          "id": {
            "properties": {
              "org": {
                "description": "Optional, org key applied to the resource.",
                "type": "string"
              }
            },
            "title": "Identifier of the metadata to update\n+required",
            "type": "object"
          },
          "metadata": {
            "$ref": "#/components/schemas/adminNamedEntityMetadata"
          }
        },
        "type": "object"
      },
      "AdminServiceUpdateProjectAttributesBody": {
        "properties": {
          "attributes": {
            "properties": {
              "matching_attributes": {
                "$ref": "#/components/schemas/adminMatchingAttributes"
              },
              "org": {
                "description": "Optional, org key applied to the project.",
                "type": "string"
              }
            },
            "title": "+required",
            "type": "object"
          }
        },
        "title": "Sets custom attributes for a project\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "AdminServiceUpdateProjectBody": {
        "description": "Top-level namespace used to classify different entities like workflows and executions.",
        "properties": {
          "description": {
            "type": "string"
          },
          "domains": {
            "items": {
              "$ref": "#/components/schemas/adminDomain"
            },
            "type": "array"
          },
          "labels": {
            "$ref": "#/components/schemas/adminLabels"
          },
          "name": {
            "description": "Display name.",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "state": {
            "$ref": "#/components/schemas/ProjectProjectState"
          }
        },
        "type": "object"
      },
      "AdminServiceUpdateProjectDomainAttributesBody": {
        "properties": {
          "attributes": {
            "properties": {
              "matching_attributes": {
                "$ref": "#/components/schemas/adminMatchingAttributes"
              },
              "org": {
                "description": "Optional, org key applied to the attributes.",
                "type": "string"
              }
            },
            "title": "+required",
            "type": "object"
          }
        },
        "title": "Sets custom attributes for a project-domain combination.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "AdminServiceUpdateWorkflowAttributesBody": {
        "properties": {
          "attributes": {
            "properties": {
              "matching_attributes": {
                "$ref": "#/components/schemas/adminMatchingAttributes"
              },
              "org": {
                "description": "Optional, org key applied to the attributes.",
                "type": "string"
              }
            },
            "title": "Defines a set of custom matching attributes which defines resource defaults for a project, domain and workflow.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
            "type": "object"
          }
        },
        "title": "Sets custom attributes for a project, domain and workflow combination.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "ArrayNodeDataMode": {
        "default": "SINGLE_INPUT_FILE",
        "description": " - SINGLE_INPUT_FILE: Indicates the ArrayNode's input is a list of input values that map to subNode executions.\nThe file path set for the subNode will be the ArrayNode's input file, but the in-memory\nvalue utilized in propeller will be the individual value for each subNode execution.\nSubNode executions need to be able to read in and parse the individual value to execute correctly.\n - INDIVIDUAL_INPUT_FILES: Indicates the ArrayNode's input is a list of input values that map to subNode executions.\nPropeller will create input files for each ArrayNode subNode by parsing the inputs and\nsetting the InputBindings on each subNodeSpec. Both the file path and in-memory input values will\nbe the individual value for each subNode execution.",
        "enum": [
          "SINGLE_INPUT_FILE",
          "INDIVIDUAL_INPUT_FILES"
        ],
        "type": "string"
      },
      "BlobTypeBlobDimensionality": {
        "default": "SINGLE",
        "enum": [
          "SINGLE",
          "MULTIPART"
        ],
        "type": "string"
      },
      "ConjunctionExpressionLogicalOperator": {
        "default": "AND",
        "description": "- AND: Conjunction",
        "enum": [
          "AND",
          "OR"
        ],
        "title": "Nested conditions. They can be conjoined using AND / OR\nOrder of evaluation is not important as the operators are Commutative",
        "type": "string"
      },
      "ConnectionSetIdList": {
        "properties": {
          "ids": {
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "ContainerArchitecture": {
        "default": "UNKNOWN",
        "description": "Architecture-type the container image supports.",
        "enum": [
          "UNKNOWN",
          "AMD64",
          "ARM64",
          "ARM_V6",
          "ARM_V7"
        ],
        "type": "string"
      },
      "ContainerContextProcessContext": {
        "properties": {
          "container_end_time": {
            "format": "date-time",
            "type": "string"
          },
          "container_start_time": {
            "format": "date-time",
            "type": "string"
          }
        },
        "title": "Contains metadata required to identify logs produces by a single light-weight process that was run inside a container",
        "type": "object"
      },
      "DataLoadingConfigLiteralMapFormat": {
        "default": "JSON",
        "description": "- JSON: JSON / YAML for the metadata (which contains inlined primitive values). The representation is inline with the standard json specification as specified - https://www.json.org/json-en.html\n - PROTO: Proto is a serialized binary of `core.LiteralMap` defined in flyteidl/core",
        "enum": [
          "JSON",
          "YAML",
          "PROTO"
        ],
        "title": "LiteralMapFormat decides the encoding format in which the input metadata should be made available to the containers.\nIf the user has access to the protocol buffer definitions, it is recommended to use the PROTO format.\nJSON and YAML do not need any protobuf definitions to read it\nAll remote references in core.LiteralMap are replaced with local filesystem references (the data is downloaded to local filesystem)",
        "type": "string"
      },
      "ExecutionErrorErrorKind": {
        "default": "UNKNOWN",
        "enum": [
          "UNKNOWN",
          "USER",
          "SYSTEM"
        ],
        "title": "Error type: System or User",
        "type": "string"
      },
      "IOStrategyDownloadMode": {
        "default": "DOWNLOAD_EAGER",
        "description": "- DOWNLOAD_EAGER: All data will be downloaded before the main container is executed\n - DOWNLOAD_STREAM: Data will be downloaded as a stream and an End-Of-Stream marker will be written to indicate all data has been downloaded. Refer to protocol for details\n - DO_NOT_DOWNLOAD: Large objects (offloaded) will not be downloaded",
        "enum": [
          "DOWNLOAD_EAGER",
          "DOWNLOAD_STREAM",
          "DO_NOT_DOWNLOAD"
        ],
        "title": "Mode to use for downloading",
        "type": "string"
      },
      "IOStrategyUploadMode": {
        "default": "UPLOAD_ON_EXIT",
        "description": "- UPLOAD_ON_EXIT: All data will be uploaded after the main container exits\n - UPLOAD_EAGER: Data will be uploaded as it appears. Refer to protocol specification for details\n - DO_NOT_UPLOAD: Data will not be uploaded, only references will be written",
        "enum": [
          "UPLOAD_ON_EXIT",
          "UPLOAD_EAGER",
          "DO_NOT_UPLOAD"
        ],
        "title": "Mode to use for uploading",
        "type": "string"
      },
      "PluginOverrideMissingPluginBehavior": {
        "default": "FAIL",
        "description": " - FAIL: By default, if this plugin is not enabled for a Flyte deployment then execution will fail.\n - USE_DEFAULT: Uses the system-configured default implementation.",
        "enum": [
          "FAIL",
          "USE_DEFAULT"
        ],
        "type": "string"
      },
      "ProjectProjectState": {
        "default": "ACTIVE",
        "description": "The state of the project is used to control its visibility in the UI and validity.\n\n - ACTIVE: By default, all projects are considered active.\n - ARCHIVED: Archived projects are no longer visible in the UI and no longer valid.\n - SYSTEM_GENERATED: System generated projects that aren't explicitly created or managed by a user.\n - SYSTEM_ARCHIVED: System archived projects that aren't explicitly archived by a user.",
        "enum": [
          "ACTIVE",
          "ARCHIVED",
          "SYSTEM_GENERATED",
          "SYSTEM_ARCHIVED"
        ],
        "type": "string"
      },
      "QualityOfServiceTier": {
        "default": "UNDEFINED",
        "description": " - UNDEFINED: Default: no quality of service specified.",
        "enum": [
          "UNDEFINED",
          "HIGH",
          "MEDIUM",
          "LOW"
        ],
        "type": "string"
      },
      "ResourcesResourceEntry": {
        "description": "Encapsulates a resource name and value.",
        "properties": {
          "name": {
            "$ref": "#/components/schemas/ResourcesResourceName"
          },
          "value": {
            "title": "Value must be a valid k8s quantity. See\nhttps://github.com/kubernetes/apimachinery/blob/master/pkg/api/resource/quantity.go#L30-L80",
            "type": "string"
          }
        },
        "type": "object"
      },
      "ResourcesResourceName": {
        "default": "UNKNOWN",
        "description": "Known resource names.\n\n - EPHEMERAL_STORAGE: For Kubernetes-based deployments, pods use ephemeral local storage for scratch space, caching, and for logs.",
        "enum": [
          "UNKNOWN",
          "CPU",
          "GPU",
          "MEMORY",
          "STORAGE",
          "EPHEMERAL_STORAGE"
        ],
        "type": "string"
      },
      "RuntimeMetadataRuntimeType": {
        "default": "OTHER",
        "enum": [
          "OTHER",
          "FLYTE_SDK"
        ],
        "type": "string"
      },
      "SchemaColumnSchemaColumnType": {
        "default": "INTEGER",
        "enum": [
          "INTEGER",
          "FLOAT",
          "STRING",
          "BOOLEAN",
          "DATETIME",
          "DURATION"
        ],
        "type": "string"
      },
      "SchemaTypeSchemaColumn": {
        "properties": {
          "name": {
            "title": "A unique name -within the schema type- for the column",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/SchemaColumnSchemaColumnType"
          }
        },
        "type": "object"
      },
      "SecretMountType": {
        "default": "ANY",
        "description": " - ANY: Default case, indicates the client can tolerate either mounting options.\n - ENV_VAR: ENV_VAR indicates the secret needs to be mounted as an environment variable.\n - FILE: FILE indicates the secret needs to be mounted as a file.",
        "enum": [
          "ANY",
          "ENV_VAR",
          "FILE"
        ],
        "type": "string"
      },
      "SortDirection": {
        "default": "DESCENDING",
        "description": " - DESCENDING: By default, fields are sorted in descending order.",
        "enum": [
          "DESCENDING",
          "ASCENDING"
        ],
        "type": "string"
      },
      "SqlDialect": {
        "default": "UNDEFINED",
        "description": "The dialect of the SQL statement. This is used to validate and parse SQL statements at compilation time to avoid\nexpensive runtime operations. If set to an unsupported dialect, no validation will be done on the statement.\nWe support the following dialect: ansi, hive.",
        "enum": [
          "UNDEFINED",
          "ANSI",
          "HIVE",
          "OTHER"
        ],
        "type": "string"
      },
      "StructuredDatasetTypeDatasetColumn": {
        "properties": {
          "literal_type": {
            "$ref": "#/components/schemas/coreLiteralType"
          },
          "name": {
            "description": "A unique name within the schema type for the column.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "TaskExecutionMetadataInstanceClass": {
        "default": "DEFAULT",
        "description": "Includes the broad category of machine used for this specific task execution.\n\n - DEFAULT: The default instance class configured for the flyte application platform.\n - INTERRUPTIBLE: The instance class configured for interruptible tasks.",
        "enum": [
          "DEFAULT",
          "INTERRUPTIBLE"
        ],
        "type": "string"
      },
      "TaskLogMessageFormat": {
        "default": "UNKNOWN",
        "enum": [
          "UNKNOWN",
          "CSV",
          "JSON"
        ],
        "type": "string"
      },
      "WorkflowMetadataOnFailurePolicy": {
        "default": "FAIL_IMMEDIATELY",
        "description": "- FAIL_IMMEDIATELY: FAIL_IMMEDIATELY instructs the system to fail as soon as a node fails in the workflow. It'll automatically\nabort all currently running nodes and clean up resources before finally marking the workflow executions as\nfailed.\n - FAIL_AFTER_EXECUTABLE_NODES_COMPLETE: FAIL_AFTER_EXECUTABLE_NODES_COMPLETE instructs the system to make as much progress as it can. The system will\nnot alter the dependencies of the execution graph so any node that depend on the failed node will not be run.\nOther nodes that will be executed to completion before cleaning up resources and marking the workflow\nexecution as failed.",
        "enum": [
          "FAIL_IMMEDIATELY",
          "FAIL_AFTER_EXECUTABLE_NODES_COMPLETE"
        ],
        "title": "Failure Handling Strategy",
        "type": "string"
      },
      "adminAbortMetadata": {
        "description": "Specifies metadata around an aborted workflow execution.",
        "properties": {
          "cause": {
            "description": "In the case of a user-specified abort, this will pass along the user-supplied cause.",
            "type": "string"
          },
          "principal": {
            "title": "Identifies the entity (if any) responsible for terminating the execution",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminAnnotations": {
        "description": "Annotation values to be applied to an execution resource.\nIn the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined\nto specify how to merge annotations defined at registration and execution time.",
        "properties": {
          "values": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Map of custom annotations to be applied to the execution resource.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "adminAuth": {
        "description": "Defines permissions associated with executions created by this launch plan spec.\nUse either of these roles when they have permissions required by your workflow execution.\nDeprecated.",
        "properties": {
          "assumable_iam_role": {
            "description": "Defines an optional iam role which will be used for tasks run in executions created with this launch plan.",
            "type": "string"
          },
          "kubernetes_service_account": {
            "description": "Defines an optional kubernetes service account which will be used for tasks run in executions created with this launch plan.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminAuthRole": {
        "description": "Defines permissions associated with executions created by this launch plan spec.\nUse either of these roles when they have permissions required by your workflow execution.\nDeprecated.",
        "properties": {
          "assumable_iam_role": {
            "description": "Defines an optional iam role which will be used for tasks run in executions created with this launch plan.",
            "type": "string"
          },
          "kubernetes_service_account": {
            "description": "Defines an optional kubernetes service account which will be used for tasks run in executions created with this launch plan.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminClusterAssignment": {
        "description": "Encapsulates specifications for routing an execution onto a specific cluster.",
        "properties": {
          "cluster_pool_name": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminClusterResourceAttributes": {
        "properties": {
          "attributes": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Custom resource attributes which will be applied in cluster resource creation (e.g. quotas).\nMap keys are the *case-sensitive* names of variables in templatized resource files.\nMap values should be the custom values which get substituted during resource creation.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "adminConcurrencyLimitBehavior": {
        "default": "CONCURRENCY_LIMIT_BEHAVIOR_UNSPECIFIED",
        "description": " - CONCURRENCY_LIMIT_BEHAVIOR_SKIP: A workflow that will be skipped because the limit has been hit.",
        "enum": [
          "CONCURRENCY_LIMIT_BEHAVIOR_UNSPECIFIED",
          "CONCURRENCY_LIMIT_BEHAVIOR_SKIP"
        ],
        "type": "string"
      },
      "adminConcurrencyPolicy": {
        "properties": {
          "behavior": {
            "$ref": "#/components/schemas/adminConcurrencyLimitBehavior"
          },
          "max": {
            "format": "int32",
            "title": "A setting for the maximum number of concurrent workflows",
            "type": "integer"
          }
        },
        "type": "object"
      },
      "adminCronSchedule": {
        "description": "Options for schedules to run according to a cron expression.",
        "properties": {
          "offset": {
            "title": "ISO 8601 duration as described by https://en.wikipedia.org/wiki/ISO_8601#Durations",
            "type": "string"
          },
          "schedule": {
            "title": "Standard/default cron implementation as described by https://en.wikipedia.org/wiki/Cron#CRON_expression;\nAlso supports nonstandard predefined scheduling definitions\nas described by https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions\nexcept @reboot",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminDescription": {
        "description": "Full user description with formatting preserved. This can be rendered\nby clients, such as the console or command line tools with in-tact\nformatting.",
        "properties": {
          "format": {
            "$ref": "#/components/schemas/adminDescriptionFormat"
          },
          "icon_link": {
            "title": "Optional link to an icon for the entity",
            "type": "string"
          },
          "uri": {
            "title": "if the description sizes exceed some threshold we can offload the entire\ndescription proto altogether to an external data store, like S3 rather than store inline in the db",
            "type": "string"
          },
          "value": {
            "title": "long description - no more than 4KB",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminDescriptionEntity": {
        "description": "DescriptionEntity contains detailed description for the task/workflow.\nDocumentation could provide insight into the algorithms, business use case, etc.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "long_description": {
            "$ref": "#/components/schemas/adminDescription"
          },
          "short_description": {
            "description": "One-liner overview of the entity.",
            "type": "string"
          },
          "source_code": {
            "$ref": "#/components/schemas/adminSourceCode"
          },
          "tags": {
            "description": "User-specified tags. These are arbitrary and can be used for searching\nfiltering and discovering tasks.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminDescriptionEntityList": {
        "properties": {
          "descriptionEntities": {
            "description": "A list of DescriptionEntities returned based on the request.",
            "items": {
              "$ref": "#/components/schemas/adminDescriptionEntity"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Represents a list of DescriptionEntities returned from the admin.\nSee DescriptionEntity for more details",
        "type": "object"
      },
      "adminDescriptionFormat": {
        "default": "DESCRIPTION_FORMAT_UNKNOWN",
        "description": "- DESCRIPTION_FORMAT_RST: python default documentation - comments is rst",
        "enum": [
          "DESCRIPTION_FORMAT_UNKNOWN",
          "DESCRIPTION_FORMAT_MARKDOWN",
          "DESCRIPTION_FORMAT_HTML",
          "DESCRIPTION_FORMAT_RST"
        ],
        "title": "The format of the long description",
        "type": "string"
      },
      "adminDomain": {
        "description": "Namespace within a project commonly used to differentiate between different service instances.\ne.g. \"production\", \"development\", etc.",
        "properties": {
          "id": {
            "description": "Globally unique domain name.",
            "type": "string"
          },
          "name": {
            "description": "Display name.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminDynamicNodeWorkflowResponse": {
        "properties": {
          "compiled_workflow": {
            "$ref": "#/components/schemas/coreCompiledWorkflowClosure"
          }
        },
        "type": "object"
      },
      "adminEmailNotification": {
        "description": "Defines an email notification specification.",
        "properties": {
          "recipients_email": {
            "items": {
              "type": "string"
            },
            "title": "The list of email addresses recipients for this notification.\n+required",
            "type": "array"
          },
          "template": {
            "title": "The template to use for this notification.\n+optional",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminEnvs": {
        "description": "Environment variable values to be applied to an execution resource.\nIn the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined\nto specify how to merge environment variables defined at registration and execution time.",
        "properties": {
          "values": {
            "description": "Map of custom environment variables to be applied to the execution resource.",
            "items": {
              "$ref": "#/components/schemas/flyteidlcoreKeyValuePair"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminExecution": {
        "description": "A workflow execution represents an instantiated workflow, including all inputs and additional\nmetadata as well as computed results included state, outputs, and duration-based attributes.\nUsed as a response object used in Get and List execution requests.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/adminExecutionClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "spec": {
            "$ref": "#/components/schemas/adminExecutionSpec"
          }
        },
        "type": "object"
      },
      "adminExecutionClosure": {
        "properties": {
          "abort_cause": {
            "description": "In the case of a user-specified abort, this will pass along the user-supplied cause.",
            "type": "string"
          },
          "abort_metadata": {
            "$ref": "#/components/schemas/adminAbortMetadata"
          },
          "computed_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "created_at": {
            "description": "Reported time at which the execution was created.",
            "format": "date-time",
            "type": "string"
          },
          "duration": {
            "description": "The amount of time the execution spent running.",
            "type": "string"
          },
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "notifications": {
            "description": "The notification settings to use after merging the CreateExecutionRequest and the launch plan\nnotification settings. An execution launched with notifications will always prefer that definition\nto notifications defined statically in a launch plan.",
            "items": {
              "$ref": "#/components/schemas/adminNotification"
            },
            "type": "array"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "outputs": {
            "$ref": "#/components/schemas/adminLiteralMapBlob"
          },
          "phase": {
            "$ref": "#/components/schemas/coreWorkflowExecutionPhase"
          },
          "started_at": {
            "description": "Reported time at which the execution began running.",
            "format": "date-time",
            "type": "string"
          },
          "state_change_details": {
            "$ref": "#/components/schemas/adminExecutionStateChangeDetails"
          },
          "updated_at": {
            "description": "Reported time at which the execution was last updated.",
            "format": "date-time",
            "type": "string"
          },
          "workflow_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "title": "Encapsulates the results of the Execution",
        "type": "object"
      },
      "adminExecutionClusterLabel": {
        "properties": {
          "value": {
            "title": "Label value to determine where the execution will be run",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminExecutionCreateRequest": {
        "description": "Request to launch an execution with the given project, domain and optionally-assigned name.",
        "properties": {
          "domain": {
            "title": "Name of the domain the execution belongs to.\nA domain can be considered as a subset within a specific project.\n+required",
            "type": "string"
          },
          "inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "name": {
            "title": "User provided value for the resource.\nIf none is provided the system will generate a unique string.\n+optional",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "project": {
            "title": "Name of the project the execution belongs to.\n+required",
            "type": "string"
          },
          "spec": {
            "$ref": "#/components/schemas/adminExecutionSpec"
          }
        },
        "type": "object"
      },
      "adminExecutionCreateResponse": {
        "description": "The unique identifier for a successfully created execution.\nIf the name was *not* specified in the create request, this identifier will include a generated name.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          }
        },
        "type": "object"
      },
      "adminExecutionList": {
        "properties": {
          "executions": {
            "items": {
              "$ref": "#/components/schemas/adminExecution"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Used as a response for request to list executions.\nSee Execution for more details",
        "type": "object"
      },
      "adminExecutionMetadata": {
        "description": "Represents attributes about an execution which are not required to launch the execution but are useful to record.\nThese attributes are assigned at launch time and do not change.",
        "properties": {
          "artifact_ids": {
            "description": "Save a list of the artifacts used in this execution for now. This is a list only rather than a mapping\nsince we don't have a structure to handle nested ones anyways.",
            "items": {
              "$ref": "#/components/schemas/coreArtifactID"
            },
            "type": "array"
          },
          "mode": {
            "$ref": "#/components/schemas/adminExecutionMetadataExecutionMode"
          },
          "nesting": {
            "description": "Indicates the nestedness of this execution.\nIf a user launches a workflow execution, the default nesting is 0.\nIf this execution further launches a workflow (child workflow), the nesting level is incremented by 0 => 1\nGenerally, if workflow at nesting level k launches a workflow then the child workflow will have\nnesting = k + 1.",
            "format": "int64",
            "type": "integer"
          },
          "parent_node_execution": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "principal": {
            "description": "Identifier of the entity that triggered this execution.\nFor systems using back-end authentication any value set here will be discarded in favor of the\nauthenticated user context.",
            "type": "string"
          },
          "reference_execution": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "scheduled_at": {
            "description": "For scheduled executions, the requested time for execution for this specific schedule invocation.",
            "format": "date-time",
            "type": "string"
          },
          "system_metadata": {
            "$ref": "#/components/schemas/adminSystemMetadata"
          }
        },
        "type": "object"
      },
      "adminExecutionMetadataExecutionMode": {
        "default": "MANUAL",
        "description": "The method by which this execution was launched.\n\n - MANUAL: The default execution mode, MANUAL implies that an execution was launched by an individual.\n - SCHEDULED: A schedule triggered this execution launch.\n - SYSTEM: A system process was responsible for launching this execution rather an individual.\n - RELAUNCH: This execution was launched with identical inputs as a previous execution.\n - CHILD_WORKFLOW: This execution was triggered by another execution.\n - RECOVERED: This execution was recovered from another execution.\n - TRIGGER: Execution was kicked off by the artifact trigger system",
        "enum": [
          "MANUAL",
          "SCHEDULED",
          "SYSTEM",
          "RELAUNCH",
          "CHILD_WORKFLOW",
          "RECOVERED",
          "TRIGGER"
        ],
        "type": "string"
      },
      "adminExecutionQueueAttributes": {
        "properties": {
          "tags": {
            "description": "Tags used for assigning execution queues for tasks defined within this project.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminExecutionRecoverRequest": {
        "description": "Request to recover the referenced execution.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "metadata": {
            "$ref": "#/components/schemas/adminExecutionMetadata"
          },
          "name": {
            "title": "User provided value for the recovered execution.\nIf none is provided the system will generate a unique string.\n+optional",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminExecutionRelaunchRequest": {
        "description": "Request to relaunch the referenced execution.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "name": {
            "title": "User provided value for the relaunched execution.\nIf none is provided the system will generate a unique string.\n+optional",
            "type": "string"
          },
          "overwrite_cache": {
            "description": "Allows for all cached values of a workflow and its tasks to be overwritten for a single execution.\nIf enabled, all calculations are performed even if cached results would be available, overwriting the stored\ndata once execution finishes successfully.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "adminExecutionSpec": {
        "description": "An ExecutionSpec encompasses all data used to launch this execution. The Spec does not change over the lifetime\nof an execution as it progresses across phase changes.",
        "properties": {
          "annotations": {
            "$ref": "#/components/schemas/adminAnnotations"
          },
          "auth_role": {
            "$ref": "#/components/schemas/adminAuthRole"
          },
          "cluster_assignment": {
            "$ref": "#/components/schemas/adminClusterAssignment"
          },
          "disable_all": {
            "description": "This should be set to true if all notifications are intended to be disabled for this execution.",
            "type": "boolean"
          },
          "envs": {
            "$ref": "#/components/schemas/adminEnvs"
          },
          "execution_cluster_label": {
            "$ref": "#/components/schemas/adminExecutionClusterLabel"
          },
          "execution_env_assignments": {
            "description": "Execution environment assignments to be set for the execution.",
            "items": {
              "$ref": "#/components/schemas/coreExecutionEnvAssignment"
            },
            "type": "array"
          },
          "inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "interruptible": {
            "description": "Allows for the interruptible flag of a workflow to be overwritten for a single execution.\nOmitting this field uses the workflow's value as a default.\nAs we need to distinguish between the field not being provided and its default value false, we have to use a wrapper\naround the bool field.",
            "type": "boolean"
          },
          "labels": {
            "$ref": "#/components/schemas/adminLabels"
          },
          "launch_plan": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "max_parallelism": {
            "description": "Controls the maximum number of task nodes that can be run in parallel for the entire workflow.\nThis is useful to achieve fairness. Note: MapTasks are regarded as one unit,\nand parallelism/concurrency of MapTasks is independent from this.",
            "format": "int32",
            "type": "integer"
          },
          "metadata": {
            "$ref": "#/components/schemas/adminExecutionMetadata"
          },
          "notifications": {
            "$ref": "#/components/schemas/adminNotificationList"
          },
          "overwrite_cache": {
            "description": "Allows for all cached values of a workflow and its tasks to be overwritten for a single execution.\nIf enabled, all calculations are performed even if cached results would be available, overwriting the stored\ndata once execution finishes successfully.",
            "type": "boolean"
          },
          "quality_of_service": {
            "$ref": "#/components/schemas/coreQualityOfService"
          },
          "raw_output_data_config": {
            "$ref": "#/components/schemas/adminRawOutputDataConfig"
          },
          "security_context": {
            "$ref": "#/components/schemas/coreSecurityContext"
          },
          "tags": {
            "description": "Tags to be set for the execution.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminExecutionState": {
        "default": "EXECUTION_ACTIVE",
        "description": "The state of the execution is used to control its visibility in the UI/CLI.\n\n - EXECUTION_ACTIVE: By default, all executions are considered active.\n - EXECUTION_ARCHIVED: Archived executions are no longer visible in the UI.",
        "enum": [
          "EXECUTION_ACTIVE",
          "EXECUTION_ARCHIVED"
        ],
        "type": "string"
      },
      "adminExecutionStateChangeDetails": {
        "properties": {
          "occurred_at": {
            "description": "This timestamp represents when the state changed.",
            "format": "date-time",
            "type": "string"
          },
          "principal": {
            "title": "Identifies the entity (if any) responsible for causing the state change of the execution",
            "type": "string"
          },
          "state": {
            "$ref": "#/components/schemas/adminExecutionState"
          }
        },
        "type": "object"
      },
      "adminExecutionTerminateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminExecutionUpdateResponse": {
        "type": "object"
      },
      "adminFixedRate": {
        "description": "Option for schedules run at a certain frequency e.g. every 2 minutes.",
        "properties": {
          "unit": {
            "$ref": "#/components/schemas/adminFixedRateUnit"
          },
          "value": {
            "format": "int64",
            "type": "integer"
          }
        },
        "type": "object"
      },
      "adminFixedRateUnit": {
        "default": "MINUTE",
        "description": "Represents a frequency at which to run a schedule.",
        "enum": [
          "MINUTE",
          "HOUR",
          "DAY"
        ],
        "type": "string"
      },
      "adminFlyteURLs": {
        "description": "These URLs are returned as part of node and task execution data requests.",
        "properties": {
          "deck": {
            "type": "string"
          },
          "inputs": {
            "type": "string"
          },
          "outputs": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminGetDomainsResponse": {
        "description": "Represents a list of domains.",
        "properties": {
          "domains": {
            "items": {
              "$ref": "#/components/schemas/adminDomain"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminGetVersionResponse": {
        "properties": {
          "control_plane_version": {
            "$ref": "#/components/schemas/adminVersion"
          }
        },
        "title": "Response for the GetVersion API",
        "type": "object"
      },
      "adminLabels": {
        "description": "Label values to be applied to an execution resource.\nIn the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined\nto specify how to merge labels defined at registration and execution time.",
        "properties": {
          "values": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Map of custom labels to be applied to the execution resource.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "adminLaunchPlan": {
        "description": "A LaunchPlan provides the capability to templatize workflow executions.\nLaunch plans simplify associating one or more schedules, inputs and notifications with your workflows.\nLaunch plans can be shared and used to trigger executions with predefined inputs even when a workflow\ndefinition doesn't necessarily have a default value for said input.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/adminLaunchPlanClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "spec": {
            "$ref": "#/components/schemas/adminLaunchPlanSpec"
          }
        },
        "type": "object"
      },
      "adminLaunchPlanClosure": {
        "description": "Values computed by the flyte platform after launch plan registration.\nThese include expected_inputs required to be present in a CreateExecutionRequest\nto launch the reference workflow as well timestamp values associated with the launch plan.",
        "properties": {
          "created_at": {
            "description": "Time at which the launch plan was created.",
            "format": "date-time",
            "type": "string"
          },
          "expected_inputs": {
            "$ref": "#/components/schemas/coreParameterMap"
          },
          "expected_outputs": {
            "$ref": "#/components/schemas/coreVariableMap"
          },
          "state": {
            "$ref": "#/components/schemas/adminLaunchPlanState"
          },
          "updated_at": {
            "description": "Time at which the launch plan was last updated.",
            "format": "date-time",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminLaunchPlanCreateRequest": {
        "description": "Request to register a launch plan. The included LaunchPlanSpec may have a complete or incomplete set of inputs required\nto launch a workflow execution. By default all launch plans are registered in state INACTIVE. If you wish to\nset the state to ACTIVE, you must submit a LaunchPlanUpdateRequest, after you have successfully created a launch plan.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "spec": {
            "$ref": "#/components/schemas/adminLaunchPlanSpec"
          }
        },
        "type": "object"
      },
      "adminLaunchPlanCreateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminLaunchPlanList": {
        "properties": {
          "launch_plans": {
            "items": {
              "$ref": "#/components/schemas/adminLaunchPlan"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Response object for list launch plan requests.\nSee LaunchPlan for more details",
        "type": "object"
      },
      "adminLaunchPlanMetadata": {
        "description": "Additional launch plan attributes included in the LaunchPlanSpec not strictly required to launch\nthe reference workflow.",
        "properties": {
          "launch_conditions": {
            "$ref": "#/components/schemas/protobufAny"
          },
          "notifications": {
            "items": {
              "$ref": "#/components/schemas/adminNotification"
            },
            "title": "List of notifications based on Execution status transitions",
            "type": "array"
          },
          "schedule": {
            "$ref": "#/components/schemas/adminSchedule"
          }
        },
        "type": "object"
      },
      "adminLaunchPlanSpec": {
        "description": "User-provided launch plan definition and configuration values.",
        "properties": {
          "annotations": {
            "$ref": "#/components/schemas/adminAnnotations"
          },
          "auth": {
            "$ref": "#/components/schemas/adminAuth"
          },
          "auth_role": {
            "$ref": "#/components/schemas/adminAuthRole"
          },
          "cluster_assignment": {
            "$ref": "#/components/schemas/adminClusterAssignment"
          },
          "concurrency_policy": {
            "$ref": "#/components/schemas/adminConcurrencyPolicy"
          },
          "default_inputs": {
            "$ref": "#/components/schemas/coreParameterMap"
          },
          "entity_metadata": {
            "$ref": "#/components/schemas/adminLaunchPlanMetadata"
          },
          "envs": {
            "$ref": "#/components/schemas/adminEnvs"
          },
          "execution_env_assignments": {
            "description": "Execution environment assignments to be set for the execution.",
            "items": {
              "$ref": "#/components/schemas/coreExecutionEnvAssignment"
            },
            "type": "array"
          },
          "fixed_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "interruptible": {
            "description": "Allows for the interruptible flag of a workflow to be overwritten for a single execution.\nOmitting this field uses the workflow's value as a default.\nAs we need to distinguish between the field not being provided and its default value false, we have to use a wrapper\naround the bool field.",
            "type": "boolean"
          },
          "labels": {
            "$ref": "#/components/schemas/adminLabels"
          },
          "max_parallelism": {
            "description": "Controls the maximum number of tasknodes that can be run in parallel for the entire workflow.\nThis is useful to achieve fairness. Note: MapTasks are regarded as one unit,\nand parallelism/concurrency of MapTasks is independent from this.",
            "format": "int32",
            "type": "integer"
          },
          "overwrite_cache": {
            "description": "Allows for all cached values of a workflow and its tasks to be overwritten for a single execution.\nIf enabled, all calculations are performed even if cached results would be available, overwriting the stored\ndata once execution finishes successfully.",
            "type": "boolean"
          },
          "quality_of_service": {
            "$ref": "#/components/schemas/coreQualityOfService"
          },
          "raw_output_data_config": {
            "$ref": "#/components/schemas/adminRawOutputDataConfig"
          },
          "role": {
            "title": "String to indicate the role to use to execute the workflow underneath",
            "type": "string"
          },
          "security_context": {
            "$ref": "#/components/schemas/coreSecurityContext"
          },
          "workflow_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "adminLaunchPlanState": {
        "default": "INACTIVE",
        "description": "By default any launch plan regardless of state can be used to launch a workflow execution.\nHowever, at most one version of a launch plan\n(e.g. a NamedEntityIdentifier set of shared project, domain and name values) can be\nactive at a time in regards to *schedules*. That is, at most one schedule in a NamedEntityIdentifier\ngroup will be observed and trigger executions at a defined cadence.",
        "enum": [
          "INACTIVE",
          "ACTIVE"
        ],
        "type": "string"
      },
      "adminLaunchPlanUpdateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminListMatchableAttributesResponse": {
        "properties": {
          "configurations": {
            "items": {
              "$ref": "#/components/schemas/adminMatchableAttributesConfiguration"
            },
            "type": "array"
          }
        },
        "title": "Response for a request for all matching resource attributes for a resource type.\nSee MatchableAttributesConfiguration for more details",
        "type": "object"
      },
      "adminLiteralMapBlob": {
        "properties": {
          "uri": {
            "title": "In the event that the map is too large, we return a uri to the data",
            "type": "string"
          },
          "values": {
            "$ref": "#/components/schemas/coreLiteralMap"
          }
        },
        "title": "Input/output data can represented by actual values or a link to where values are stored",
        "type": "object"
      },
      "adminMatchableAttributesConfiguration": {
        "description": "Represents a custom set of attributes applied for either a domain (and optional org); a domain and project (and optional org);\nor domain, project and workflow name (and optional org).\nThese are used to override system level defaults for kubernetes cluster resource management,\ndefault execution values, and more all across different levels of specificity.",
        "properties": {
          "attributes": {
            "$ref": "#/components/schemas/adminMatchingAttributes"
          },
          "domain": {
            "type": "string"
          },
          "launch_plan": {
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "project": {
            "type": "string"
          },
          "workflow": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminMatchableResource": {
        "default": "TASK_RESOURCE",
        "description": "Defines a resource that can be configured by customizable Project-, ProjectDomain- or WorkflowAttributes\nbased on matching tags.\n\n - TASK_RESOURCE: Applies to customizable task resource requests and limits.\n - CLUSTER_RESOURCE: Applies to configuring templated kubernetes cluster resources.\n - EXECUTION_QUEUE: Configures task and dynamic task execution queue assignment.\n - EXECUTION_CLUSTER_LABEL: Configures the K8s cluster label to be used for execution to be run\n - QUALITY_OF_SERVICE_SPECIFICATION: Configures default quality of service when undefined in an execution spec.\n - PLUGIN_OVERRIDE: Selects configurable plugin implementation behavior for a given task type.\n - WORKFLOW_EXECUTION_CONFIG: Adds defaults for customizable workflow-execution specifications and overrides.\n - CLUSTER_ASSIGNMENT: Controls how to select an available cluster on which this execution should run.",
        "enum": [
          "TASK_RESOURCE",
          "CLUSTER_RESOURCE",
          "EXECUTION_QUEUE",
          "EXECUTION_CLUSTER_LABEL",
          "QUALITY_OF_SERVICE_SPECIFICATION",
          "PLUGIN_OVERRIDE",
          "WORKFLOW_EXECUTION_CONFIG",
          "CLUSTER_ASSIGNMENT"
        ],
        "type": "string"
      },
      "adminMatchingAttributes": {
        "description": "Generic container for encapsulating all types of the above attributes messages.",
        "properties": {
          "cluster_assignment": {
            "$ref": "#/components/schemas/adminClusterAssignment"
          },
          "cluster_resource_attributes": {
            "$ref": "#/components/schemas/adminClusterResourceAttributes"
          },
          "execution_cluster_label": {
            "$ref": "#/components/schemas/adminExecutionClusterLabel"
          },
          "execution_queue_attributes": {
            "$ref": "#/components/schemas/adminExecutionQueueAttributes"
          },
          "plugin_overrides": {
            "$ref": "#/components/schemas/adminPluginOverrides"
          },
          "quality_of_service": {
            "$ref": "#/components/schemas/coreQualityOfService"
          },
          "task_resource_attributes": {
            "$ref": "#/components/schemas/adminTaskResourceAttributes"
          },
          "workflow_execution_config": {
            "$ref": "#/components/schemas/adminWorkflowExecutionConfig"
          }
        },
        "type": "object"
      },
      "adminNamedEntity": {
        "description": "Encapsulates information common to a NamedEntity, a Flyte resource such as a task,\nworkflow or launch plan. A NamedEntity is exclusively identified by its resource type\nand identifier.",
        "properties": {
          "id": {
            "$ref": "#/components/schemas/adminNamedEntityIdentifier"
          },
          "metadata": {
            "$ref": "#/components/schemas/adminNamedEntityMetadata"
          },
          "resource_type": {
            "$ref": "#/components/schemas/coreResourceType"
          }
        },
        "type": "object"
      },
      "adminNamedEntityIdentifier": {
        "description": "Encapsulation of fields that identifies a Flyte resource.\nA Flyte resource can be a task, workflow or launch plan.\nA resource can internally have multiple versions and is uniquely identified\nby project, domain, and name.",
        "properties": {
          "domain": {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "type": "string"
          },
          "name": {
            "title": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "project": {
            "description": "Name of the project the resource belongs to.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminNamedEntityIdentifierList": {
        "description": "Represents a list of NamedEntityIdentifiers.",
        "properties": {
          "entities": {
            "description": "A list of identifiers.",
            "items": {
              "$ref": "#/components/schemas/adminNamedEntityIdentifier"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminNamedEntityList": {
        "description": "Represents a list of NamedEntityIdentifiers.",
        "properties": {
          "entities": {
            "items": {
              "$ref": "#/components/schemas/adminNamedEntity"
            },
            "title": "A list of NamedEntity objects",
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminNamedEntityMetadata": {
        "description": "Additional metadata around a named entity.",
        "properties": {
          "description": {
            "title": "Common description across all versions of the entity\n+optional",
            "type": "string"
          },
          "state": {
            "$ref": "#/components/schemas/adminNamedEntityState"
          }
        },
        "type": "object"
      },
      "adminNamedEntityState": {
        "default": "NAMED_ENTITY_ACTIVE",
        "description": "The status of the named entity is used to control its visibility in the UI.\n\n - NAMED_ENTITY_ACTIVE: By default, all named entities are considered active and under development.\n - NAMED_ENTITY_ARCHIVED: Archived named entities are no longer visible in the UI.\n - SYSTEM_GENERATED: System generated entities that aren't explicitly created or managed by a user.",
        "enum": [
          "NAMED_ENTITY_ACTIVE",
          "NAMED_ENTITY_ARCHIVED",
          "SYSTEM_GENERATED"
        ],
        "type": "string"
      },
      "adminNamedEntityUpdateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminNodeExecutionClosure": {
        "description": "Container for node execution details and results.",
        "properties": {
          "created_at": {
            "description": "Time at which the node execution was created.",
            "format": "date-time",
            "type": "string"
          },
          "deck_uri": {
            "title": "String location uniquely identifying where the deck HTML file is.\nNativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar)",
            "type": "string"
          },
          "duration": {
            "description": "The amount of time the node execution spent running.",
            "type": "string"
          },
          "dynamic_job_spec_uri": {
            "description": "dynamic_job_spec_uri is the location of the DynamicJobSpec proto message for a DynamicWorkflow. This is required\nto correctly recover partially completed executions where the subworkflow has already been compiled.",
            "type": "string"
          },
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "output_uri": {
            "description": "Links to a remotely stored, serialized core.LiteralMap of node execution outputs.\nDEPRECATED. Use GetNodeExecutionData to fetch output data instead.",
            "type": "string"
          },
          "phase": {
            "$ref": "#/components/schemas/coreNodeExecutionPhase"
          },
          "started_at": {
            "description": "Time at which the node execution began running.",
            "format": "date-time",
            "type": "string"
          },
          "task_node_metadata": {
            "$ref": "#/components/schemas/flyteidladminTaskNodeMetadata"
          },
          "updated_at": {
            "description": "Time at which the node execution was last updated.",
            "format": "date-time",
            "type": "string"
          },
          "workflow_node_metadata": {
            "$ref": "#/components/schemas/flyteidladminWorkflowNodeMetadata"
          }
        },
        "type": "object"
      },
      "adminNodeExecutionEventRequest": {
        "description": "Request to send a notification that a node execution event has occurred.",
        "properties": {
          "event": {
            "$ref": "#/components/schemas/eventNodeExecutionEvent"
          },
          "request_id": {
            "title": "Unique ID for this request that can be traced between services",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminNodeExecutionEventResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminNodeExecutionGetDataResponse": {
        "description": "Response structure for NodeExecutionGetDataRequest which contains inputs and outputs for a node execution.",
        "properties": {
          "dynamic_workflow": {
            "$ref": "#/components/schemas/flyteidladminDynamicWorkflowNodeMetadata"
          },
          "flyte_urls": {
            "$ref": "#/components/schemas/adminFlyteURLs"
          },
          "full_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "full_outputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "inputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          },
          "outputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          }
        },
        "type": "object"
      },
      "adminNodeExecutionList": {
        "properties": {
          "node_executions": {
            "items": {
              "$ref": "#/components/schemas/flyteidladminNodeExecution"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Request structure to retrieve a list of node execution entities.\nSee NodeExecution for more details",
        "type": "object"
      },
      "adminNodeExecutionMetaData": {
        "properties": {
          "is_array": {
            "description": "Boolean flag indicating if the node is an array node. This is intended to uniquely identify\narray nodes from other nodes which can have is_parent_node as true.",
            "type": "boolean"
          },
          "is_dynamic": {
            "description": "Boolean flag indicating if the node has contains a dynamic workflow which then produces child nodes.\nThis is to distinguish between subworkflows and dynamic workflows which can both have is_parent_node as true.",
            "type": "boolean"
          },
          "is_eager": {
            "description": "Whether this node is an eager node.",
            "type": "boolean"
          },
          "is_parent_node": {
            "description": "Boolean flag indicating if the node has child nodes under it\nThis can be true when a node contains a dynamic workflow which then produces\nchild nodes.",
            "type": "boolean"
          },
          "retry_group": {
            "description": "Node executions are grouped depending on retries of the parent\nRetry group is unique within the context of a parent node.",
            "type": "string"
          },
          "spec_node_id": {
            "title": "Node id of the node in the original workflow\nThis maps to value of WorkflowTemplate.nodes[X].id",
            "type": "string"
          }
        },
        "title": "Represents additional attributes related to a Node Execution",
        "type": "object"
      },
      "adminNotification": {
        "description": "Represents a structure for notifications based on execution status.\nThe notification content is configured within flyte admin but can be templatized.\nFuture iterations could expose configuring notifications with custom content.",
        "properties": {
          "email": {
            "$ref": "#/components/schemas/adminEmailNotification"
          },
          "pager_duty": {
            "$ref": "#/components/schemas/adminPagerDutyNotification"
          },
          "phases": {
            "items": {
              "$ref": "#/components/schemas/coreWorkflowExecutionPhase"
            },
            "title": "A list of phases to which users can associate the notifications to.\n+required",
            "type": "array"
          },
          "slack": {
            "$ref": "#/components/schemas/adminSlackNotification"
          }
        },
        "type": "object"
      },
      "adminNotificationList": {
        "properties": {
          "notifications": {
            "items": {
              "$ref": "#/components/schemas/adminNotification"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminPagerDutyNotification": {
        "description": "Defines a pager duty notification specification.",
        "properties": {
          "recipients_email": {
            "items": {
              "type": "string"
            },
            "title": "Currently, PagerDuty notifications leverage email to trigger a notification.\n+required",
            "type": "array"
          },
          "template": {
            "title": "The template to use for this notification.\n+optional",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminPluginOverride": {
        "description": "This MatchableAttribute configures selecting alternate plugin implementations for a given task type.\nIn addition to an override implementation a selection of fallbacks can be provided or other modes\nfor handling cases where the desired plugin override is not enabled in a given Flyte deployment.",
        "properties": {
          "missing_plugin_behavior": {
            "$ref": "#/components/schemas/PluginOverrideMissingPluginBehavior"
          },
          "plugin_id": {
            "description": "A set of plugin ids which should handle tasks of this type instead of the default registered plugin. The list will be tried in order until a plugin is found with that id.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "task_type": {
            "description": "A predefined yet extensible Task type identifier.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminPluginOverrides": {
        "properties": {
          "overrides": {
            "items": {
              "$ref": "#/components/schemas/adminPluginOverride"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "adminProject": {
        "description": "Top-level namespace used to classify different entities like workflows and executions.",
        "properties": {
          "description": {
            "type": "string"
          },
          "domains": {
            "items": {
              "$ref": "#/components/schemas/adminDomain"
            },
            "type": "array"
          },
          "id": {
            "description": "Globally unique project name.",
            "type": "string"
          },
          "labels": {
            "$ref": "#/components/schemas/adminLabels"
          },
          "name": {
            "description": "Display name.",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "state": {
            "$ref": "#/components/schemas/ProjectProjectState"
          }
        },
        "type": "object"
      },
      "adminProjectAttributes": {
        "properties": {
          "matching_attributes": {
            "$ref": "#/components/schemas/adminMatchingAttributes"
          },
          "org": {
            "description": "Optional, org key applied to the project.",
            "type": "string"
          },
          "project": {
            "description": "Unique project id for which this set of attributes will be applied.",
            "type": "string"
          }
        },
        "title": "Defines a set of custom matching attributes at the project level.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "adminProjectAttributesDeleteResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminProjectAttributesGetResponse": {
        "properties": {
          "attributes": {
            "$ref": "#/components/schemas/adminProjectAttributes"
          }
        },
        "title": "Response to get an individual project level attribute override.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "adminProjectAttributesUpdateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminProjectDomainAttributes": {
        "properties": {
          "domain": {
            "description": "Unique domain id for which this set of attributes will be applied.",
            "type": "string"
          },
          "matching_attributes": {
            "$ref": "#/components/schemas/adminMatchingAttributes"
          },
          "org": {
            "description": "Optional, org key applied to the attributes.",
            "type": "string"
          },
          "project": {
            "description": "Unique project id for which this set of attributes will be applied.",
            "type": "string"
          }
        },
        "title": "Defines a set of custom matching attributes which defines resource defaults for a project and domain.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "adminProjectDomainAttributesDeleteResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminProjectDomainAttributesGetResponse": {
        "properties": {
          "attributes": {
            "$ref": "#/components/schemas/adminProjectDomainAttributes"
          }
        },
        "title": "Response to get an individual project domain attribute override.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "adminProjectDomainAttributesUpdateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminProjectRegisterRequest": {
        "properties": {
          "project": {
            "$ref": "#/components/schemas/adminProject"
          }
        },
        "title": "Adds a new user-project within the Flyte deployment.\nSee Project for more details",
        "type": "object"
      },
      "adminProjectRegisterResponse": {
        "description": "Purposefully empty, may be updated in the future.",
        "type": "object"
      },
      "adminProjectUpdateResponse": {
        "description": "Purposefully empty, may be updated in the future.",
        "type": "object"
      },
      "adminProjects": {
        "properties": {
          "projects": {
            "items": {
              "$ref": "#/components/schemas/adminProject"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Represents a list of projects.\nSee Project for more details",
        "type": "object"
      },
      "adminRawOutputDataConfig": {
        "description": "Encapsulates user settings pertaining to offloaded data (i.e. Blobs, Schema, query data, etc.).\nSee https://github.com/flyteorg/flyte/issues/211 for more background information.",
        "properties": {
          "output_location_prefix": {
            "title": "Prefix for where offloaded data from user workflows will be written\ne.g. s3://bucket/key or s3://bucket/",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminReason": {
        "description": "Reason is a single message annotated with a timestamp to indicate the instant the reason occurred.",
        "properties": {
          "message": {
            "description": "message is the explanation for the most recent phase transition or status update.",
            "type": "string"
          },
          "occurred_at": {
            "description": "occurred_at is the timestamp indicating the instant that this reason happened.",
            "format": "date-time",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminSchedule": {
        "description": "Defines complete set of information required to trigger an execution on a schedule.",
        "properties": {
          "cron_expression": {
            "title": "Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year\ne.g. for a schedule that runs every 15 minutes: 0/15 * * * ? *",
            "type": "string"
          },
          "cron_schedule": {
            "$ref": "#/components/schemas/adminCronSchedule"
          },
          "kickoff_time_input_arg": {
            "description": "Name of the input variable that the kickoff time will be supplied to when the workflow is kicked off.",
            "type": "string"
          },
          "rate": {
            "$ref": "#/components/schemas/adminFixedRate"
          }
        },
        "type": "object"
      },
      "adminSlackNotification": {
        "description": "Defines a slack notification specification.",
        "properties": {
          "recipients_email": {
            "items": {
              "type": "string"
            },
            "title": "Currently, Slack notifications leverage email to trigger a notification.\n+required",
            "type": "array"
          },
          "template": {
            "title": "The template to use for this notification.\n+optional",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminSort": {
        "description": "Specifies sort ordering in a list request.",
        "properties": {
          "direction": {
            "$ref": "#/components/schemas/SortDirection"
          },
          "key": {
            "title": "Indicates an attribute to sort the response values.\n+required",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminSourceCode": {
        "properties": {
          "link": {
            "type": "string"
          }
        },
        "title": "Link to source code used to define this entity",
        "type": "object"
      },
      "adminSystemMetadata": {
        "description": "Represents system, rather than user-facing, metadata about an execution.",
        "properties": {
          "execution_cluster": {
            "description": "Which execution cluster this execution ran on.",
            "type": "string"
          },
          "namespace": {
            "description": "Which kubernetes namespace the execution ran under.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTask": {
        "description": "Flyte workflows are composed of many ordered tasks. That is small, reusable, self-contained logical blocks\narranged to process workflow inputs and produce a deterministic set of outputs.\nTasks can come in many varieties tuned for specialized behavior.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/adminTaskClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "short_description": {
            "description": "One-liner overview of the entity.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTaskClosure": {
        "description": "Compute task attributes which include values derived from the TaskSpec, as well as plugin-specific data\nand task metadata.",
        "properties": {
          "compiled_task": {
            "$ref": "#/components/schemas/coreCompiledTask"
          },
          "created_at": {
            "description": "Time at which the task was created.",
            "format": "date-time",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTaskExecutionClosure": {
        "description": "Container for task execution details and results.",
        "properties": {
          "created_at": {
            "description": "Time at which the task execution was created.",
            "format": "date-time",
            "type": "string"
          },
          "custom_info": {
            "description": "Custom data specific to the task plugin.",
            "type": "object"
          },
          "duration": {
            "description": "The amount of time the task execution spent running.",
            "type": "string"
          },
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "event_version": {
            "description": "The event version is used to indicate versioned changes in how data is maintained using this\nproto message. For example, event_verison > 0 means that maps tasks logs use the\nTaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog\nin this message.",
            "format": "int32",
            "type": "integer"
          },
          "log_context": {
            "$ref": "#/components/schemas/coreLogContext"
          },
          "logs": {
            "description": "Detailed log information output by the task execution.",
            "items": {
              "$ref": "#/components/schemas/coreTaskLog"
            },
            "type": "array"
          },
          "metadata": {
            "$ref": "#/components/schemas/flyteidleventTaskExecutionMetadata"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "output_uri": {
            "description": "Path to remote data store where output blob is stored if the execution succeeded (and produced outputs).\nDEPRECATED. Use GetTaskExecutionData to fetch output data instead.",
            "type": "string"
          },
          "phase": {
            "$ref": "#/components/schemas/coreTaskExecutionPhase"
          },
          "reason": {
            "description": "If there is an explanation for the most recent phase transition, the reason will capture it.",
            "type": "string"
          },
          "reasons": {
            "description": "A time-series of the phase transition or update explanations. This, when compared to storing a singular reason\nas previously done, is much more valuable in visualizing and understanding historical evaluations.",
            "items": {
              "$ref": "#/components/schemas/adminReason"
            },
            "type": "array"
          },
          "started_at": {
            "description": "Time at which the task execution began running.",
            "format": "date-time",
            "type": "string"
          },
          "task_type": {
            "description": "A predefined yet extensible Task type identifier.",
            "type": "string"
          },
          "updated_at": {
            "description": "Time at which the task execution was last updated.",
            "format": "date-time",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTaskExecutionEventRequest": {
        "description": "Request to send a notification that a task execution event has occurred.",
        "properties": {
          "event": {
            "$ref": "#/components/schemas/eventTaskExecutionEvent"
          },
          "request_id": {
            "title": "Unique ID for this request that can be traced between services",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTaskExecutionEventResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminTaskExecutionGetDataResponse": {
        "description": "Response structure for TaskExecutionGetDataRequest which contains inputs and outputs for a task execution.",
        "properties": {
          "flyte_urls": {
            "$ref": "#/components/schemas/adminFlyteURLs"
          },
          "full_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "full_outputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "inputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          },
          "outputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          }
        },
        "type": "object"
      },
      "adminTaskExecutionList": {
        "properties": {
          "task_executions": {
            "items": {
              "$ref": "#/components/schemas/flyteidladminTaskExecution"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Response structure for a query to list of task execution entities.\nSee TaskExecution for more details",
        "type": "object"
      },
      "adminTaskList": {
        "properties": {
          "tasks": {
            "description": "A list of tasks returned based on the request.",
            "items": {
              "$ref": "#/components/schemas/adminTask"
            },
            "type": "array"
          },
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          }
        },
        "title": "Represents a list of tasks returned from the admin.\nSee Task for more details",
        "type": "object"
      },
      "adminTaskResourceAttributes": {
        "description": "Defines task resource defaults and limits that will be applied at task registration.",
        "properties": {
          "defaults": {
            "$ref": "#/components/schemas/adminTaskResourceSpec"
          },
          "limits": {
            "$ref": "#/components/schemas/adminTaskResourceSpec"
          }
        },
        "type": "object"
      },
      "adminTaskResourceSpec": {
        "description": "Defines a set of overridable task resource attributes set during task registration.",
        "properties": {
          "cpu": {
            "type": "string"
          },
          "ephemeral_storage": {
            "type": "string"
          },
          "gpu": {
            "type": "string"
          },
          "memory": {
            "type": "string"
          },
          "storage": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminTaskSpec": {
        "description": "Represents a structure that encapsulates the user-configured specification of the task.",
        "properties": {
          "description": {
            "$ref": "#/components/schemas/adminDescriptionEntity"
          },
          "template": {
            "$ref": "#/components/schemas/coreTaskTemplate"
          }
        },
        "type": "object"
      },
      "adminUrlBlob": {
        "description": "Represents a string url and associated metadata used throughout the platform.",
        "properties": {
          "bytes": {
            "description": "Represents the size of the file accessible at the above url.",
            "format": "int64",
            "type": "string"
          },
          "url": {
            "description": "Actual url value.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminVersion": {
        "properties": {
          "Build": {
            "title": "Specifies the GIT sha of the build",
            "type": "string"
          },
          "BuildTime": {
            "title": "Build timestamp",
            "type": "string"
          },
          "Version": {
            "title": "Version for the build, should follow a semver",
            "type": "string"
          }
        },
        "title": "Provides Version information for a component",
        "type": "object"
      },
      "adminWorkflow": {
        "description": "Represents the workflow structure stored in the Admin\nA workflow is created by ordering tasks and associating outputs to inputs\nin order to produce a directed-acyclic execution graph.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/flyteidladminWorkflowClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "short_description": {
            "description": "One-liner overview of the entity.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminWorkflowAttributes": {
        "properties": {
          "domain": {
            "description": "Unique domain id for which this set of attributes will be applied.",
            "type": "string"
          },
          "matching_attributes": {
            "$ref": "#/components/schemas/adminMatchingAttributes"
          },
          "org": {
            "description": "Optional, org key applied to the attributes.",
            "type": "string"
          },
          "project": {
            "description": "Unique project id for which this set of attributes will be applied.",
            "type": "string"
          },
          "workflow": {
            "description": "Workflow name for which this set of attributes will be applied.",
            "type": "string"
          }
        },
        "title": "Defines a set of custom matching attributes which defines resource defaults for a project, domain and workflow.\nFor more info on matchable attributes, see MatchableAttributesConfiguration",
        "type": "object"
      },
      "adminWorkflowAttributesDeleteResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminWorkflowAttributesGetResponse": {
        "description": "Response to get an individual workflow attribute override.",
        "properties": {
          "attributes": {
            "$ref": "#/components/schemas/adminWorkflowAttributes"
          }
        },
        "type": "object"
      },
      "adminWorkflowAttributesUpdateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminWorkflowCreateRequest": {
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "spec": {
            "$ref": "#/components/schemas/adminWorkflowSpec"
          }
        },
        "title": "Represents a request structure to create a revision of a workflow.\nSee Workflow for more details",
        "type": "object"
      },
      "adminWorkflowCreateResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminWorkflowExecutionConfig": {
        "description": "Adds defaults for customizable workflow-execution specifications and overrides.",
        "properties": {
          "annotations": {
            "$ref": "#/components/schemas/adminAnnotations"
          },
          "envs": {
            "$ref": "#/components/schemas/adminEnvs"
          },
          "execution_env_assignments": {
            "description": "Execution environment assignments to be set for the execution.",
            "items": {
              "$ref": "#/components/schemas/coreExecutionEnvAssignment"
            },
            "type": "array"
          },
          "interruptible": {
            "description": "Allows for the interruptible flag of a workflow to be overwritten for a single execution.\nOmitting this field uses the workflow's value as a default.\nAs we need to distinguish between the field not being provided and its default value false, we have to use a wrapper\naround the bool field.",
            "type": "boolean"
          },
          "labels": {
            "$ref": "#/components/schemas/adminLabels"
          },
          "max_parallelism": {
            "description": "Can be used to control the number of parallel nodes to run within the workflow. This is useful to achieve fairness.",
            "format": "int32",
            "type": "integer"
          },
          "overwrite_cache": {
            "description": "Allows for all cached values of a workflow and its tasks to be overwritten for a single execution.\nIf enabled, all calculations are performed even if cached results would be available, overwriting the stored\ndata once execution finishes successfully.",
            "type": "boolean"
          },
          "raw_output_data_config": {
            "$ref": "#/components/schemas/adminRawOutputDataConfig"
          },
          "security_context": {
            "$ref": "#/components/schemas/coreSecurityContext"
          }
        },
        "type": "object"
      },
      "adminWorkflowExecutionEventRequest": {
        "description": "Request to send a notification that a workflow execution event has occurred.",
        "properties": {
          "event": {
            "$ref": "#/components/schemas/eventWorkflowExecutionEvent"
          },
          "request_id": {
            "title": "Unique ID for this request that can be traced between services",
            "type": "string"
          }
        },
        "type": "object"
      },
      "adminWorkflowExecutionEventResponse": {
        "description": "Purposefully empty, may be populated in the future.",
        "type": "object"
      },
      "adminWorkflowExecutionGetDataResponse": {
        "description": "Response structure for WorkflowExecutionGetDataRequest which contains inputs and outputs for an execution.",
        "properties": {
          "full_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "full_outputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "inputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          },
          "outputs": {
            "$ref": "#/components/schemas/adminUrlBlob"
          }
        },
        "type": "object"
      },
      "adminWorkflowExecutionGetMetricsResponse": {
        "description": "WorkflowExecutionGetMetricsResponse represents the response containing metrics for the specified workflow execution.",
        "properties": {
          "span": {
            "$ref": "#/components/schemas/coreSpan"
          }
        },
        "type": "object"
      },
      "adminWorkflowList": {
        "properties": {
          "token": {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query. If there are no more results, this value will be empty.",
            "type": "string"
          },
          "workflows": {
            "description": "A list of workflows returned based on the request.",
            "items": {
              "$ref": "#/components/schemas/adminWorkflow"
            },
            "type": "array"
          }
        },
        "title": "Represents a list of workflows returned from the admin.\nSee Workflow for more details",
        "type": "object"
      },
      "adminWorkflowSpec": {
        "description": "Represents a structure that encapsulates the specification of the workflow.",
        "properties": {
          "description": {
            "$ref": "#/components/schemas/adminDescriptionEntity"
          },
          "sub_workflows": {
            "description": "Workflows that are embedded into other workflows need to be passed alongside the parent workflow to the\npropeller compiler (since the compiler doesn't have any knowledge of other workflows - ie, it doesn't reach out\nto Admin to see other registered workflows).  In fact, subworkflows do not even need to be registered.",
            "items": {
              "$ref": "#/components/schemas/coreWorkflowTemplate"
            },
            "type": "array"
          },
          "template": {
            "$ref": "#/components/schemas/coreWorkflowTemplate"
          }
        },
        "type": "object"
      },
      "coreAlias": {
        "description": "Links a variable to an alias.",
        "properties": {
          "alias": {
            "description": "A workflow-level unique alias that downstream nodes can refer to in their input.",
            "type": "string"
          },
          "var": {
            "description": "Must match one of the output variable names on a node.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreApproveCondition": {
        "description": "ApproveCondition represents a dependency on an external approval. During execution, this will manifest as a boolean\nsignal with the provided signal_id.",
        "properties": {
          "signal_id": {
            "description": "A unique identifier for the requested boolean signal.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreArrayNode": {
        "description": "ArrayNode is a Flyte node type that simplifies the execution of a sub-node over a list of input\nvalues. An ArrayNode can be executed with configurable parallelism (separate from the parent\nworkflow) and can be configured to succeed when a certain number of sub-nodes succeed.",
        "properties": {
          "bound_inputs": {
            "description": "+optional. Specifies input bindings that are not mapped over for the node.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "data_mode": {
            "$ref": "#/components/schemas/ArrayNodeDataMode"
          },
          "execution_mode": {
            "$ref": "#/components/schemas/coreArrayNodeExecutionMode"
          },
          "is_original_sub_node_interface": {
            "title": "Indicates whether the sub node's original interface was altered",
            "type": "boolean"
          },
          "min_success_ratio": {
            "description": "If the array job size is not known beforehand, the min_success_ratio can instead be used\nto determine when an ArrayNode can be marked successful.",
            "format": "float",
            "type": "number"
          },
          "min_successes": {
            "description": "min_successes is an absolute number of the minimum number of successful completions of\nsub-nodes. As soon as this criteria is met, the ArrayNode will be marked as successful\nand outputs will be computed. This has to be a non-negative number if assigned. Default\nvalue is size (if specified).",
            "format": "int64",
            "type": "integer"
          },
          "node": {
            "$ref": "#/components/schemas/coreNode"
          },
          "parallelism": {
            "description": "parallelism defines the minimum number of instances to bring up concurrently at any given\npoint. Note that this is an optimistic restriction and that, due to network partitioning or\nother failures, the actual number of currently running instances might be more. This has to\nbe a positive number if assigned. Default value is size.",
            "format": "int64",
            "type": "integer"
          },
          "run_all_sub_nodes": {
            "description": "+optional. If set to true, the ArrayNode will continue to run all sub-nodes even after the\nfailure threshold has been met (i.e. it is no longer possible to meet min_successes or\nmin_success_ratio). This is useful when you want to ensure all sub-nodes complete execution\neven if the overall array node will fail.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "coreArrayNodeExecutionMode": {
        "default": "MINIMAL_STATE",
        "description": " - MINIMAL_STATE: Indicates the ArrayNode will store minimal state for the sub-nodes.\nThis is more efficient, but only supports a subset of Flyte entities.\n - FULL_STATE: Indicates the ArrayNode will store full state for the sub-nodes.\nThis supports a wider range of Flyte entities.",
        "enum": [
          "MINIMAL_STATE",
          "FULL_STATE"
        ],
        "type": "string"
      },
      "coreArtifactBindingData": {
        "properties": {
          "bind_to_time_partition": {
            "type": "boolean"
          },
          "partition_key": {
            "type": "string"
          },
          "time_transform": {
            "$ref": "#/components/schemas/coreTimeTransform"
          }
        },
        "title": "Only valid for triggers",
        "type": "object"
      },
      "coreArtifactID": {
        "properties": {
          "artifact_key": {
            "$ref": "#/components/schemas/coreArtifactKey"
          },
          "partitions": {
            "$ref": "#/components/schemas/corePartitions"
          },
          "time_partition": {
            "$ref": "#/components/schemas/coreTimePartition"
          },
          "version": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreArtifactKey": {
        "properties": {
          "domain": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "org": {
            "type": "string"
          },
          "project": {
            "description": "Project and domain and suffix needs to be unique across a given artifact store.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreArtifactQuery": {
        "properties": {
          "artifact_id": {
            "$ref": "#/components/schemas/coreArtifactID"
          },
          "artifact_tag": {
            "$ref": "#/components/schemas/coreArtifactTag"
          },
          "binding": {
            "$ref": "#/components/schemas/coreArtifactBindingData"
          },
          "uri": {
            "type": "string"
          }
        },
        "title": "Uniqueness constraints for Artifacts\n - project, domain, name, version, partitions\nOption 2 (tags are standalone, point to an individual artifact id):\n - project, domain, name, alias (points to one partition if partitioned)\n - project, domain, name, partition key, partition value",
        "type": "object"
      },
      "coreArtifactTag": {
        "properties": {
          "artifact_key": {
            "$ref": "#/components/schemas/coreArtifactKey"
          },
          "value": {
            "$ref": "#/components/schemas/coreLabelValue"
          }
        },
        "type": "object"
      },
      "coreBinary": {
        "description": "A simple byte array with a tag to help different parts of the system communicate about what is in the byte array.\nIt's strongly advisable that consumers of this type define a unique tag and validate the tag before parsing the data.",
        "properties": {
          "tag": {
            "description": "The serialization format identifier (e.g., MessagePack). Consumers must define unique tags and validate them before deserialization.",
            "type": "string"
          },
          "value": {
            "description": "Serialized data (MessagePack) for supported types like Dataclass, Pydantic BaseModel, and untyped dict.",
            "format": "byte",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreBinding": {
        "description": "An input/output binding of a variable to either static value or a node output.",
        "properties": {
          "binding": {
            "$ref": "#/components/schemas/coreBindingData"
          },
          "var": {
            "description": "Variable name must match an input/output variable of the node.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreBindingData": {
        "description": "Specifies either a simple value or a reference to another output.",
        "properties": {
          "collection": {
            "$ref": "#/components/schemas/coreBindingDataCollection"
          },
          "map": {
            "$ref": "#/components/schemas/coreBindingDataMap"
          },
          "offloaded_metadata": {
            "$ref": "#/components/schemas/coreLiteralOffloadedMetadata"
          },
          "promise": {
            "$ref": "#/components/schemas/coreOutputReference"
          },
          "scalar": {
            "$ref": "#/components/schemas/coreScalar"
          },
          "union": {
            "$ref": "#/components/schemas/coreUnionInfo"
          }
        },
        "type": "object"
      },
      "coreBindingDataCollection": {
        "description": "A collection of BindingData items.",
        "properties": {
          "bindings": {
            "items": {
              "$ref": "#/components/schemas/coreBindingData"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreBindingDataMap": {
        "description": "A map of BindingData items.",
        "properties": {
          "bindings": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreBindingData"
            },
            "type": "object"
          }
        },
        "type": "object"
      },
      "coreBlob": {
        "description": "Refers to an offloaded set of files. It encapsulates the type of the store and a unique uri for where the data is.\nThere are no restrictions on how the uri is formatted since it will depend on how to interact with the store.",
        "properties": {
          "metadata": {
            "$ref": "#/components/schemas/coreBlobMetadata"
          },
          "uri": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreBlobMetadata": {
        "properties": {
          "type": {
            "$ref": "#/components/schemas/coreBlobType"
          }
        },
        "type": "object"
      },
      "coreBlobType": {
        "properties": {
          "dimensionality": {
            "$ref": "#/components/schemas/BlobTypeBlobDimensionality"
          },
          "format": {
            "title": "Format can be a free form string understood by SDK/UI etc like\ncsv, parquet etc",
            "type": "string"
          }
        },
        "title": "Defines type behavior for blob objects",
        "type": "object"
      },
      "coreBooleanExpression": {
        "description": "Defines a boolean expression tree. It can be a simple or a conjunction expression.\nMultiple expressions can be combined using a conjunction or a disjunction to result in a final boolean result.",
        "properties": {
          "comparison": {
            "$ref": "#/components/schemas/coreComparisonExpression"
          },
          "conjunction": {
            "$ref": "#/components/schemas/coreConjunctionExpression"
          }
        },
        "type": "object"
      },
      "coreBranchNode": {
        "description": "BranchNode is a special node that alter the flow of the workflow graph. It allows the control flow to branch at\nruntime based on a series of conditions that get evaluated on various parameters (e.g. inputs, primitives).",
        "properties": {
          "if_else": {
            "$ref": "#/components/schemas/coreIfElseBlock"
          }
        },
        "type": "object"
      },
      "coreCatalogArtifactTag": {
        "properties": {
          "artifact_id": {
            "title": "Artifact ID is generated name",
            "type": "string"
          },
          "name": {
            "title": "Flyte computes the tag automatically, as the hash of the values",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreCatalogCacheStatus": {
        "default": "CACHE_DISABLED",
        "description": "- CACHE_DISABLED: Used to indicate that caching was disabled\n - CACHE_MISS: Used to indicate that the cache lookup resulted in no matches\n - CACHE_HIT: used to indicate that the associated artifact was a result of a previous execution\n - CACHE_POPULATED: used to indicate that the resultant artifact was added to the cache\n - CACHE_LOOKUP_FAILURE: Used to indicate that cache lookup failed because of an error\n - CACHE_PUT_FAILURE: Used to indicate that cache lookup failed because of an error\n - CACHE_SKIPPED: Used to indicate the cache lookup was skipped\n - CACHE_EVICTED: Used to indicate that the cache was evicted",
        "enum": [
          "CACHE_DISABLED",
          "CACHE_MISS",
          "CACHE_HIT",
          "CACHE_POPULATED",
          "CACHE_LOOKUP_FAILURE",
          "CACHE_PUT_FAILURE",
          "CACHE_SKIPPED",
          "CACHE_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",
        "type": "string"
      },
      "coreCatalogMetadata": {
        "properties": {
          "artifact_tag": {
            "$ref": "#/components/schemas/coreCatalogArtifactTag"
          },
          "dataset_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "source_task_execution": {
            "$ref": "#/components/schemas/coreTaskExecutionIdentifier"
          }
        },
        "title": "Catalog artifact information with specific metadata",
        "type": "object"
      },
      "coreCatalogReservationStatus": {
        "default": "RESERVATION_DISABLED",
        "description": "Indicates the status of a catalog reservation operation.\n\n - RESERVATION_DISABLED: Used to indicate that reservations are disabled\n - RESERVATION_ACQUIRED: Used to indicate that a reservation was successfully acquired or extended\n - RESERVATION_EXISTS: Used to indicate that an active reservation currently exists\n - RESERVATION_RELEASED: Used to indicate that the reservation has been successfully released\n - RESERVATION_FAILURE: Used to indicate that a reservation operation resulted in failure",
        "enum": [
          "RESERVATION_DISABLED",
          "RESERVATION_ACQUIRED",
          "RESERVATION_EXISTS",
          "RESERVATION_RELEASED",
          "RESERVATION_FAILURE"
        ],
        "type": "string"
      },
      "coreComparisonExpression": {
        "description": "Defines a 2-level tree where the root is a comparison operator and Operands are primitives or known variables.\nEach expression results in a boolean result.",
        "properties": {
          "left_value": {
            "$ref": "#/components/schemas/coreOperand"
          },
          "operator": {
            "$ref": "#/components/schemas/coreComparisonExpressionOperator"
          },
          "right_value": {
            "$ref": "#/components/schemas/coreOperand"
          }
        },
        "type": "object"
      },
      "coreComparisonExpressionOperator": {
        "default": "EQ",
        "description": "- GT: Greater Than\n - LT: Less Than",
        "enum": [
          "EQ",
          "NEQ",
          "GT",
          "GTE",
          "LT",
          "LTE"
        ],
        "title": "Binary Operator for each expression",
        "type": "string"
      },
      "coreCompiledLaunchPlan": {
        "properties": {
          "template": {
            "$ref": "#/components/schemas/coreLaunchPlanTemplate"
          }
        },
        "title": "Output of the compilation step. This object represents one LaunchPlan. We store more metadata at this layer",
        "type": "object"
      },
      "coreCompiledTask": {
        "properties": {
          "template": {
            "$ref": "#/components/schemas/coreTaskTemplate"
          }
        },
        "title": "Output of the Compilation step. This object represent one Task. We store more metadata at this layer",
        "type": "object"
      },
      "coreCompiledWorkflow": {
        "properties": {
          "connections": {
            "$ref": "#/components/schemas/coreConnectionSet"
          },
          "template": {
            "$ref": "#/components/schemas/coreWorkflowTemplate"
          }
        },
        "title": "Output of the compilation Step. This object represents one workflow. We store more metadata at this layer",
        "type": "object"
      },
      "coreCompiledWorkflowClosure": {
        "description": "A Compiled Workflow Closure contains all the information required to start a new execution, or to visualize a workflow\nand its details. The CompiledWorkflowClosure should always contain a primary workflow, that is the main workflow that\nwill being the execution. All subworkflows are denormalized. WorkflowNodes refer to the workflow identifiers of\ncompiled subworkflows.",
        "properties": {
          "launch_plans": {
            "description": "A collection of launch plans that are compiled. Guaranteed that there will only exist one and only one launch plan\nwith a given id, i.e., every launch plan has a unique id.",
            "items": {
              "$ref": "#/components/schemas/coreCompiledLaunchPlan"
            },
            "type": "array"
          },
          "primary": {
            "$ref": "#/components/schemas/coreCompiledWorkflow"
          },
          "sub_workflows": {
            "items": {
              "$ref": "#/components/schemas/coreCompiledWorkflow"
            },
            "title": "Guaranteed that there will only exist one and only one workflow with a given id, i.e., every sub workflow has a\nunique identifier. Also every enclosed subworkflow is used either by a primary workflow or by a subworkflow\nas an inlined workflow\n+optional",
            "type": "array"
          },
          "tasks": {
            "items": {
              "$ref": "#/components/schemas/coreCompiledTask"
            },
            "title": "Guaranteed that there will only exist one and only one task with a given id, i.e., every task has a unique id\n+required (at least 1)",
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreConjunctionExpression": {
        "description": "Defines a conjunction expression of two boolean expressions.",
        "properties": {
          "left_expression": {
            "$ref": "#/components/schemas/coreBooleanExpression"
          },
          "operator": {
            "$ref": "#/components/schemas/ConjunctionExpressionLogicalOperator"
          },
          "right_expression": {
            "$ref": "#/components/schemas/coreBooleanExpression"
          }
        },
        "type": "object"
      },
      "coreConnectionSet": {
        "properties": {
          "downstream": {
            "additionalProperties": {
              "$ref": "#/components/schemas/ConnectionSetIdList"
            },
            "title": "A list of all the node ids that are downstream from a given node id",
            "type": "object"
          },
          "upstream": {
            "additionalProperties": {
              "$ref": "#/components/schemas/ConnectionSetIdList"
            },
            "title": "A list of all the node ids, that are upstream of this node id",
            "type": "object"
          }
        },
        "title": "Adjacency list for the workflow. This is created as part of the compilation process. Every process after the compilation\nstep uses this created ConnectionSet",
        "type": "object"
      },
      "coreContainer": {
        "properties": {
          "architecture": {
            "$ref": "#/components/schemas/ContainerArchitecture"
          },
          "args": {
            "description": "These will default to Flyte given paths. If provided, the system will not append known paths. If the task still\nneeds flyte's inputs and outputs path, add $(FLYTE_INPUT_FILE), $(FLYTE_OUTPUT_FILE) wherever makes sense and the\nsystem will populate these before executing the container.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "command": {
            "description": "Command to be executed, if not provided, the default entrypoint in the container image will be used.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "config": {
            "description": "Allows extra configs to be available for the container.\nTODO: elaborate on how configs will become available.\nDeprecated, please use TaskTemplate.config instead.",
            "items": {
              "$ref": "#/components/schemas/flyteidlcoreKeyValuePair"
            },
            "type": "array"
          },
          "data_config": {
            "$ref": "#/components/schemas/coreDataLoadingConfig"
          },
          "env": {
            "description": "Environment variables will be set as the container is starting up.",
            "items": {
              "$ref": "#/components/schemas/flyteidlcoreKeyValuePair"
            },
            "type": "array"
          },
          "image": {
            "title": "Container image url. Eg: docker/redis:latest",
            "type": "string"
          },
          "ports": {
            "items": {
              "$ref": "#/components/schemas/coreContainerPort"
            },
            "title": "Ports to open in the container. This feature is not supported by all execution engines. (e.g. supported on K8s but\nnot supported on AWS Batch)\nOnly K8s",
            "type": "array"
          },
          "resources": {
            "$ref": "#/components/schemas/coreResources"
          }
        },
        "type": "object"
      },
      "coreContainerContext": {
        "properties": {
          "container_name": {
            "type": "string"
          },
          "process": {
            "$ref": "#/components/schemas/ContainerContextProcessContext"
          }
        },
        "title": "Contains metadata required to identify logs produces by a single container",
        "type": "object"
      },
      "coreContainerPort": {
        "description": "Defines port properties for a container.",
        "properties": {
          "container_port": {
            "description": "Number of port to expose on the pod's IP address.\nThis must be a valid port number, 0 < x < 65536.",
            "format": "int64",
            "type": "integer"
          },
          "name": {
            "description": "Name of the port to expose on the pod's IP address.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreDataLoadingConfig": {
        "description": "This configuration allows executing raw containers in Flyte using the Flyte CoPilot system.\nFlyte CoPilot, eliminates the needs of flytekit or sdk inside the container. Any inputs required by the users container are side-loaded in the input_path\nAny outputs generated by the user container - within output_path are automatically uploaded.",
        "properties": {
          "enabled": {
            "title": "Flag enables DataLoading Config. If this is not set, data loading will not be used!",
            "type": "boolean"
          },
          "format": {
            "$ref": "#/components/schemas/DataLoadingConfigLiteralMapFormat"
          },
          "input_path": {
            "title": "File system path (start at root). This folder will contain all the inputs exploded to a separate file.\nExample, if the input interface needs (x: int, y: blob, z: multipart_blob) and the input path is '/var/flyte/inputs', then the file system will look like\n/var/flyte/inputs/inputs.<metadata format dependent -> .pb .json .yaml> -> Format as defined previously. The Blob and Multipart blob will reference local filesystem instead of remote locations\n/var/flyte/inputs/x -> X is a file that contains the value of x (integer) in string format\n/var/flyte/inputs/y -> Y is a file in Binary format\n/var/flyte/inputs/z/... -> Note Z itself is a directory\nMore information about the protocol - refer to docs #TODO reference docs here",
            "type": "string"
          },
          "io_strategy": {
            "$ref": "#/components/schemas/coreIOStrategy"
          },
          "output_path": {
            "title": "File system path (start at root). This folder should contain all the outputs for the task as individual files and/or an error text file",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreError": {
        "description": "Represents an error thrown from a node.",
        "properties": {
          "failed_node_id": {
            "description": "The node id that threw the error.",
            "type": "string"
          },
          "message": {
            "description": "Error message thrown.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreExecutionEnv": {
        "description": "ExecutionEnv is a message that is used to specify the execution environment.",
        "properties": {
          "extant": {
            "description": "extant is a reference to an existing environment.",
            "type": "object"
          },
          "name": {
            "description": "name is a human-readable identifier for the execution environment. This is combined with the\nproject, domain, and version to uniquely identify an execution environment.",
            "type": "string"
          },
          "spec": {
            "description": "spec is a specification of the environment.",
            "type": "object"
          },
          "type": {
            "description": "type is the type of the execution environment.",
            "type": "string"
          },
          "version": {
            "description": "version is the version of the execution environment. This may be used differently by each\nindividual environment type (ex. auto-generated or manually provided), but is intended to\nallow variance in environment specifications with the same ID.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreExecutionEnvAssignment": {
        "description": "ExecutionEnvAssignment is a message that is used to assign an execution environment to a set of\nnodes.",
        "properties": {
          "execution_env": {
            "$ref": "#/components/schemas/coreExecutionEnv"
          },
          "node_ids": {
            "description": "node_ids is a list of node ids that are being assigned the execution environment.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "task_type": {
            "description": "task_type is the type of task that is being assigned. This is used to override which Flyte\nplugin will be used during execution.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreExecutionError": {
        "description": "Represents the error message from the execution.",
        "properties": {
          "code": {
            "title": "Error code indicates a grouping of a type of error.\nMore Info: <Link>",
            "type": "string"
          },
          "error_uri": {
            "title": "Full error contents accessible via a URI",
            "type": "string"
          },
          "kind": {
            "$ref": "#/components/schemas/ExecutionErrorErrorKind"
          },
          "message": {
            "description": "Detailed description of the error - including stack trace.",
            "type": "string"
          },
          "timestamp": {
            "format": "date-time",
            "title": "Timestamp of the error",
            "type": "string"
          },
          "worker": {
            "title": "Worker that generated the error",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreExtendedResources": {
        "description": "Encapsulates all non-standard resources, not captured by v1.ResourceRequirements, to\nallocate to a task.",
        "properties": {
          "gpu_accelerator": {
            "$ref": "#/components/schemas/coreGPUAccelerator"
          },
          "shared_memory": {
            "$ref": "#/components/schemas/coreSharedMemory"
          }
        },
        "type": "object"
      },
      "coreGPUAccelerator": {
        "description": "Metadata associated with the GPU accelerator to allocate to a task. Contains\ninformation about device type, and for multi-instance GPUs, the partition size to\nuse.",
        "properties": {
          "device": {
            "description": "This can be any arbitrary string, and should be informed by the labels or taints\nassociated with the nodes in question. Default cloud provider labels typically\nuse the following values: `nvidia-tesla-t4`, `nvidia-tesla-a100`, etc.",
            "type": "string"
          },
          "partition_size": {
            "description": "Like `device`, this can be any arbitrary string, and should be informed by\nthe labels or taints associated with the nodes in question. Default cloud\nprovider labels typically use the following values: `1g.5gb`, `2g.10gb`, etc.",
            "type": "string"
          },
          "unpartitioned": {
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "coreGateNode": {
        "description": "GateNode refers to the condition that is required for the gate to successfully complete.",
        "properties": {
          "approve": {
            "$ref": "#/components/schemas/coreApproveCondition"
          },
          "signal": {
            "$ref": "#/components/schemas/coreSignalCondition"
          },
          "sleep": {
            "$ref": "#/components/schemas/coreSleepCondition"
          }
        },
        "type": "object"
      },
      "coreGranularity": {
        "default": "UNSET",
        "enum": [
          "UNSET",
          "MINUTE",
          "HOUR",
          "DAY",
          "MONTH"
        ],
        "title": "- DAY: default",
        "type": "string"
      },
      "coreIOStrategy": {
        "properties": {
          "download_mode": {
            "$ref": "#/components/schemas/IOStrategyDownloadMode"
          },
          "upload_mode": {
            "$ref": "#/components/schemas/IOStrategyUploadMode"
          }
        },
        "title": "Strategy to use when dealing with Blob, Schema, or multipart blob data (large datasets)",
        "type": "object"
      },
      "coreIdentifier": {
        "description": "Encapsulation of fields that uniquely identifies a Flyte resource.",
        "properties": {
          "domain": {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "type": "string"
          },
          "name": {
            "description": "User provided value for the resource.",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "project": {
            "description": "Name of the project the resource belongs to.",
            "type": "string"
          },
          "resource_type": {
            "$ref": "#/components/schemas/coreResourceType"
          },
          "version": {
            "description": "Specific version of the resource.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreIdentity": {
        "description": "Identity encapsulates the various security identities a task can run as. It's up to the underlying plugin to pick the\nright identity for the execution environment.",
        "properties": {
          "execution_identity": {
            "title": "execution_identity references the subject who makes the execution",
            "type": "string"
          },
          "iam_role": {
            "description": "iam_role references the fully qualified name of Identity & Access Management role to impersonate.",
            "type": "string"
          },
          "k8s_service_account": {
            "description": "k8s_service_account references a kubernetes service account to impersonate.",
            "type": "string"
          },
          "oauth2_client": {
            "$ref": "#/components/schemas/coreOAuth2Client"
          }
        },
        "type": "object"
      },
      "coreIfBlock": {
        "description": "Defines a condition and the execution unit that should be executed if the condition is satisfied.",
        "properties": {
          "condition": {
            "$ref": "#/components/schemas/coreBooleanExpression"
          },
          "then_node": {
            "$ref": "#/components/schemas/coreNode"
          }
        },
        "type": "object"
      },
      "coreIfElseBlock": {
        "description": "Defines a series of if/else blocks. The first branch whose condition evaluates to true is the one to execute.\nIf no conditions were satisfied, the else_node or the error will execute.",
        "properties": {
          "case": {
            "$ref": "#/components/schemas/coreIfBlock"
          },
          "else_node": {
            "$ref": "#/components/schemas/coreNode"
          },
          "error": {
            "$ref": "#/components/schemas/coreError"
          },
          "other": {
            "description": "+optional. Additional branches to evaluate.",
            "items": {
              "$ref": "#/components/schemas/coreIfBlock"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreInputBindingData": {
        "properties": {
          "var": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreK8sObjectMetadata": {
        "description": "Metadata for building a kubernetes object when a task is executed.",
        "properties": {
          "annotations": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Optional annotations to add to the pod definition.",
            "type": "object"
          },
          "labels": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Optional labels to add to the pod definition.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "coreK8sPod": {
        "description": "Defines a pod spec and additional pod metadata that is created when a task is executed.",
        "properties": {
          "data_config": {
            "$ref": "#/components/schemas/coreDataLoadingConfig"
          },
          "metadata": {
            "$ref": "#/components/schemas/coreK8sObjectMetadata"
          },
          "pod_spec": {
            "title": "Defines the primary pod spec created when a task is executed.\nThis should be a JSON-marshalled pod spec, which can be defined in\n- go, using: https://github.com/kubernetes/api/blob/release-1.21/core/v1/types.go#L2936\n- python: using https://github.com/kubernetes-client/python/blob/release-19.0/kubernetes/client/models/v1_pod_spec.py",
            "type": "object"
          },
          "primary_container_name": {
            "description": "Defines the primary container name when pod template override is executed.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreLabelValue": {
        "properties": {
          "input_binding": {
            "$ref": "#/components/schemas/coreInputBindingData"
          },
          "runtime_binding": {
            "$ref": "#/components/schemas/coreRuntimeBinding"
          },
          "static_value": {
            "title": "The string static value is for use in the Partitions object",
            "type": "string"
          },
          "time_value": {
            "format": "date-time",
            "title": "The time value is for use in the TimePartition case",
            "type": "string"
          },
          "triggered_binding": {
            "$ref": "#/components/schemas/coreArtifactBindingData"
          }
        },
        "type": "object"
      },
      "coreLaunchPlanTemplate": {
        "description": "A structure that uniquely identifies a launch plan in the system.",
        "properties": {
          "fixed_inputs": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "interface": {
            "$ref": "#/components/schemas/coreTypedInterface"
          }
        },
        "type": "object"
      },
      "coreLiteral": {
        "description": "A simple value. This supports any level of nesting (e.g. array of array of array of Blobs) as well as simple primitives.",
        "properties": {
          "collection": {
            "$ref": "#/components/schemas/coreLiteralCollection"
          },
          "hash": {
            "title": "A hash representing this literal.\nThis is used for caching purposes. For more details refer to RFC 1893\n(https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md)",
            "type": "string"
          },
          "map": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "metadata": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Additional metadata for literals.",
            "type": "object"
          },
          "offloaded_metadata": {
            "$ref": "#/components/schemas/coreLiteralOffloadedMetadata"
          },
          "scalar": {
            "$ref": "#/components/schemas/coreScalar"
          }
        },
        "type": "object"
      },
      "coreLiteralCollection": {
        "description": "A collection of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field.",
        "properties": {
          "literals": {
            "items": {
              "$ref": "#/components/schemas/coreLiteral"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreLiteralMap": {
        "description": "A map of literals. This is a workaround since oneofs in proto messages cannot contain a repeated field.",
        "properties": {
          "literals": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreLiteral"
            },
            "type": "object"
          }
        },
        "type": "object"
      },
      "coreLiteralOffloadedMetadata": {
        "description": "A message that contains the metadata of the offloaded data.",
        "properties": {
          "inferred_type": {
            "$ref": "#/components/schemas/coreLiteralType"
          },
          "size_bytes": {
            "description": "The size of the offloaded data.",
            "format": "uint64",
            "type": "string"
          },
          "uri": {
            "description": "The location of the offloaded core.Literal.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreLiteralType": {
        "description": "Defines a strong type to allow type checking between interfaces.",
        "properties": {
          "annotation": {
            "$ref": "#/components/schemas/coreTypeAnnotation"
          },
          "blob": {
            "$ref": "#/components/schemas/coreBlobType"
          },
          "collection_type": {
            "$ref": "#/components/schemas/coreLiteralType"
          },
          "enum_type": {
            "$ref": "#/components/schemas/flyteidlcoreEnumType"
          },
          "map_value_type": {
            "$ref": "#/components/schemas/coreLiteralType"
          },
          "metadata": {
            "description": "This field contains type metadata that is descriptive of the type, but is NOT considered in type-checking.  This might be used by\nconsumers to identify special behavior or display extended information for the type.",
            "type": "object"
          },
          "schema": {
            "$ref": "#/components/schemas/coreSchemaType"
          },
          "simple": {
            "$ref": "#/components/schemas/coreSimpleType"
          },
          "structure": {
            "$ref": "#/components/schemas/coreTypeStructure"
          },
          "structured_dataset_type": {
            "$ref": "#/components/schemas/coreStructuredDatasetType"
          },
          "union_type": {
            "$ref": "#/components/schemas/coreUnionType"
          }
        },
        "type": "object"
      },
      "coreLogContext": {
        "properties": {
          "pods": {
            "items": {
              "$ref": "#/components/schemas/corePodLogContext"
            },
            "type": "array"
          },
          "primary_pod_name": {
            "type": "string"
          }
        },
        "title": "Contains metadata required to identify logs produces by a set of pods",
        "type": "object"
      },
      "coreNode": {
        "description": "A Workflow graph Node. One unit of execution in the graph. Each node can be linked to a Task, a Workflow or a branch\nnode.",
        "properties": {
          "array_node": {
            "$ref": "#/components/schemas/coreArrayNode"
          },
          "branch_node": {
            "$ref": "#/components/schemas/coreBranchNode"
          },
          "gate_node": {
            "$ref": "#/components/schemas/coreGateNode"
          },
          "id": {
            "description": "A workflow-level unique identifier that identifies this node in the workflow. 'inputs' and 'outputs' are reserved\nnode ids that cannot be used by other nodes.",
            "type": "string"
          },
          "inputs": {
            "description": "Specifies how to bind the underlying interface's inputs. All required inputs specified in the underlying interface\nmust be fulfilled.",
            "items": {
              "$ref": "#/components/schemas/coreBinding"
            },
            "type": "array"
          },
          "metadata": {
            "$ref": "#/components/schemas/coreNodeMetadata"
          },
          "output_aliases": {
            "description": "+optional. A node can define aliases for a subset of its outputs. This is particularly useful if different nodes\nneed to conform to the same interface (e.g. all branches in a branch node). Downstream nodes must refer to this\nnodes outputs using the alias if one's specified.",
            "items": {
              "$ref": "#/components/schemas/coreAlias"
            },
            "type": "array"
          },
          "task_node": {
            "$ref": "#/components/schemas/coreTaskNode"
          },
          "upstream_node_ids": {
            "description": "+optional Specifies execution dependency for this node ensuring it will only get scheduled to run after all its\nupstream nodes have completed. This node will have an implicit dependency on any node that appears in inputs\nfield.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "workflow_node": {
            "$ref": "#/components/schemas/coreWorkflowNode"
          }
        },
        "type": "object"
      },
      "coreNodeExecutionIdentifier": {
        "description": "Encapsulation of fields that identify a Flyte node execution entity.",
        "properties": {
          "execution_id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "node_id": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreNodeExecutionPhase": {
        "default": "UNDEFINED",
        "enum": [
          "UNDEFINED",
          "QUEUED",
          "RUNNING",
          "SUCCEEDED",
          "FAILING",
          "FAILED",
          "ABORTED",
          "SKIPPED",
          "TIMED_OUT",
          "DYNAMIC_RUNNING",
          "RECOVERED"
        ],
        "type": "string"
      },
      "coreNodeMetadata": {
        "description": "Defines extra information about the Node.",
        "properties": {
          "cache_serializable": {
            "type": "boolean"
          },
          "cache_version": {
            "type": "string"
          },
          "cacheable": {
            "type": "boolean"
          },
          "config": {
            "additionalProperties": {
              "type": "string"
            },
            "description": "Config is a bag of properties that can be used to instruct propeller on how to execute the node.",
            "type": "object"
          },
          "interruptible": {
            "type": "boolean"
          },
          "name": {
            "title": "A friendly name for the Node",
            "type": "string"
          },
          "retries": {
            "$ref": "#/components/schemas/coreRetryStrategy"
          },
          "timeout": {
            "description": "The overall timeout of a task.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreOAuth2Client": {
        "description": "OAuth2Client encapsulates OAuth2 Client Credentials to be used when making calls on behalf of that task.",
        "properties": {
          "client_id": {
            "title": "client_id is the public id for the client to use. The system will not perform any pre-auth validation that the\nsecret requested matches the client_id indicated here.\n+required",
            "type": "string"
          },
          "client_secret": {
            "$ref": "#/components/schemas/coreSecret"
          }
        },
        "type": "object"
      },
      "coreOAuth2TokenRequest": {
        "description": "OAuth2TokenRequest encapsulates information needed to request an OAuth2 token.\nFLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if\ntokens are passed through environment variables.\nFLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the path where secrets will be mounted if tokens\nare passed through file mounts.",
        "properties": {
          "client": {
            "$ref": "#/components/schemas/coreOAuth2Client"
          },
          "idp_discovery_endpoint": {
            "title": "idp_discovery_endpoint references the discovery endpoint used to retrieve token endpoint and other related\ninformation.\n+optional",
            "type": "string"
          },
          "name": {
            "title": "name indicates a unique id for the token request within this task token requests. It'll be used as a suffix for\nenvironment variables and as a filename for mounting tokens as files.\n+required",
            "type": "string"
          },
          "token_endpoint": {
            "title": "token_endpoint references the token issuance endpoint. If idp_discovery_endpoint is not provided, this parameter is\nmandatory.\n+optional",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/coreOAuth2TokenRequestType"
          }
        },
        "type": "object"
      },
      "coreOAuth2TokenRequestType": {
        "default": "CLIENT_CREDENTIALS",
        "description": "Type of the token requested.\n\n - CLIENT_CREDENTIALS: CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials.",
        "enum": [
          "CLIENT_CREDENTIALS"
        ],
        "type": "string"
      },
      "coreOperand": {
        "description": "Defines an operand to a comparison expression.",
        "properties": {
          "primitive": {
            "$ref": "#/components/schemas/corePrimitive"
          },
          "scalar": {
            "$ref": "#/components/schemas/coreScalar"
          },
          "var": {
            "title": "Or one of this node's input variables",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreOutputReference": {
        "description": "A reference to an output produced by a node. The type can be retrieved -and validated- from\nthe underlying interface of the node.",
        "properties": {
          "attr_path": {
            "items": {
              "$ref": "#/components/schemas/corePromiseAttribute"
            },
            "type": "array"
          },
          "node_id": {
            "description": "Node id must exist at the graph layer.",
            "type": "string"
          },
          "var": {
            "description": "Variable name must refer to an output variable for the node.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreParameter": {
        "description": "A parameter is used as input to a launch plan and has\nthe special ability to have a default value or mark itself as required.",
        "properties": {
          "artifact_id": {
            "$ref": "#/components/schemas/coreArtifactID"
          },
          "artifact_query": {
            "$ref": "#/components/schemas/coreArtifactQuery"
          },
          "default": {
            "$ref": "#/components/schemas/coreLiteral"
          },
          "required": {
            "description": "+optional, is this value required to be filled.",
            "type": "boolean"
          },
          "var": {
            "$ref": "#/components/schemas/coreVariable"
          }
        },
        "type": "object"
      },
      "coreParameterMap": {
        "description": "A map of Parameters.",
        "properties": {
          "parameters": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreParameter"
            },
            "description": "Defines a map of parameter names to parameters.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "corePartitions": {
        "properties": {
          "value": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreLabelValue"
            },
            "type": "object"
          }
        },
        "type": "object"
      },
      "corePodLogContext": {
        "properties": {
          "containers": {
            "items": {
              "$ref": "#/components/schemas/coreContainerContext"
            },
            "type": "array"
          },
          "init_containers": {
            "items": {
              "$ref": "#/components/schemas/coreContainerContext"
            },
            "type": "array"
          },
          "namespace": {
            "type": "string"
          },
          "pod_name": {
            "type": "string"
          },
          "primary_container_name": {
            "type": "string"
          }
        },
        "title": "Contains metadata required to identify logs produces by a single pod",
        "type": "object"
      },
      "corePrimitive": {
        "properties": {
          "boolean": {
            "type": "boolean"
          },
          "datetime": {
            "format": "date-time",
            "type": "string"
          },
          "duration": {
            "type": "string"
          },
          "float_value": {
            "format": "double",
            "type": "number"
          },
          "integer": {
            "format": "int64",
            "type": "string"
          },
          "string_value": {
            "type": "string"
          }
        },
        "title": "Primitive Types",
        "type": "object"
      },
      "corePromiseAttribute": {
        "properties": {
          "int_value": {
            "format": "int32",
            "type": "integer"
          },
          "string_value": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreQualityOfService": {
        "description": "Indicates the priority of an execution.",
        "properties": {
          "spec": {
            "$ref": "#/components/schemas/coreQualityOfServiceSpec"
          },
          "tier": {
            "$ref": "#/components/schemas/QualityOfServiceTier"
          }
        },
        "type": "object"
      },
      "coreQualityOfServiceSpec": {
        "description": "Represents customized execution run-time attributes.",
        "properties": {
          "queueing_budget": {
            "description": "Indicates how much queueing delay an execution can tolerate.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreResourceType": {
        "default": "UNSPECIFIED",
        "description": "Indicates a resource type within Flyte.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
        "enum": [
          "UNSPECIFIED",
          "TASK",
          "WORKFLOW",
          "LAUNCH_PLAN",
          "DATASET"
        ],
        "type": "string"
      },
      "coreResources": {
        "description": "A customizable interface to convey resources requested for a container. This can be interpreted differently for different\ncontainer engines.",
        "properties": {
          "limits": {
            "description": "Defines a set of bounds (e.g. min/max) within which the task can reliably run. ResourceNames must be unique\nwithin the list.",
            "items": {
              "$ref": "#/components/schemas/ResourcesResourceEntry"
            },
            "type": "array"
          },
          "requests": {
            "description": "The desired set of resources requested. ResourceNames must be unique within the list.",
            "items": {
              "$ref": "#/components/schemas/ResourcesResourceEntry"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreRetryStrategy": {
        "description": "Retry strategy associated with an executable unit.",
        "properties": {
          "retries": {
            "description": "Number of retries. Retries will be consumed when the job fails with a recoverable error.\nThe number of retries must be less than or equals to 10.",
            "format": "int64",
            "type": "integer"
          }
        },
        "type": "object"
      },
      "coreRuntimeBinding": {
        "type": "object"
      },
      "coreRuntimeMetadata": {
        "description": "Runtime information. This is loosely defined to allow for extensibility.",
        "properties": {
          "flavor": {
            "description": "+optional It can be used to provide extra information about the runtime (e.g. python, golang... etc.).",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/RuntimeMetadataRuntimeType"
          },
          "version": {
            "description": "Version of the runtime. All versions should be backward compatible. However, certain cases call for version\nchecks to ensure tighter validation or setting expectations.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreScalar": {
        "properties": {
          "binary": {
            "$ref": "#/components/schemas/coreBinary"
          },
          "blob": {
            "$ref": "#/components/schemas/coreBlob"
          },
          "error": {
            "$ref": "#/components/schemas/coreError"
          },
          "generic": {
            "type": "object"
          },
          "none_type": {
            "$ref": "#/components/schemas/coreVoid"
          },
          "primitive": {
            "$ref": "#/components/schemas/corePrimitive"
          },
          "schema": {
            "$ref": "#/components/schemas/flyteidlcoreSchema"
          },
          "structured_dataset": {
            "$ref": "#/components/schemas/coreStructuredDataset"
          },
          "union": {
            "$ref": "#/components/schemas/coreUnion"
          }
        },
        "type": "object"
      },
      "coreSchemaType": {
        "description": "Defines schema columns and types to strongly type-validate schemas interoperability.",
        "properties": {
          "columns": {
            "description": "A list of ordered columns this schema comprises of.",
            "items": {
              "$ref": "#/components/schemas/SchemaTypeSchemaColumn"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreSecret": {
        "description": "Secret encapsulates information about the secret a task needs to proceed. An environment variable\nFLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the environment variables that will be present if\nsecrets are passed through environment variables.\nFLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the path where secrets will be mounted if secrets\nare passed through file mounts.",
        "properties": {
          "env_var": {
            "title": "env_var is optional. Custom environment variable to set the value of the secret. If mount_requirement is ENV_VAR,\nthen the value is the secret itself. If mount_requirement is FILE, then the value is the path to the secret file.\n+optional",
            "type": "string"
          },
          "group": {
            "title": "The name of the secret group where to find the key referenced below. For K8s secrets, this should be the name of\nthe v1/secret object. For Confidant, this should be the Credential name. For Vault, this should be the secret name.\nFor AWS Secret Manager, this should be the name of the secret.\n+required",
            "type": "string"
          },
          "group_version": {
            "title": "The group version to fetch. This is not supported in all secret management systems. It'll be ignored for the ones\nthat do not support it.\n+optional",
            "type": "string"
          },
          "key": {
            "title": "The name of the secret to mount. This has to match an existing secret in the system. It's up to the implementation\nof the secret management system to require case sensitivity. For K8s secrets, Confidant and Vault, this should\nmatch one of the keys inside the secret. For AWS Secret Manager, it's ignored.\n+optional",
            "type": "string"
          },
          "mount_requirement": {
            "$ref": "#/components/schemas/SecretMountType"
          }
        },
        "type": "object"
      },
      "coreSecurityContext": {
        "description": "SecurityContext holds security attributes that apply to tasks.",
        "properties": {
          "run_as": {
            "$ref": "#/components/schemas/coreIdentity"
          },
          "secrets": {
            "description": "secrets indicate the list of secrets the task needs in order to proceed. Secrets will be mounted/passed to the\npod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS\nBatch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access\nto the secret) and to pass it to the remote execution engine.",
            "items": {
              "$ref": "#/components/schemas/coreSecret"
            },
            "type": "array"
          },
          "tokens": {
            "description": "tokens indicate the list of token requests the task needs in order to proceed. Tokens will be mounted/passed to the\npod as it starts. If the plugin responsible for kicking of the task will not run it on a flyte cluster (e.g. AWS\nBatch), it's the responsibility of the plugin to fetch the secret (which means propeller identity will need access\nto the secret) and to pass it to the remote execution engine.",
            "items": {
              "$ref": "#/components/schemas/coreOAuth2TokenRequest"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreSharedMemory": {
        "description": "Metadata associated with configuring a shared memory volume for a task.",
        "properties": {
          "mount_name": {
            "title": "Name for volume",
            "type": "string"
          },
          "mount_path": {
            "title": "Mount path to place in container",
            "type": "string"
          },
          "size_limit": {
            "title": "Size limit for shared memory. If not set, then the shared memory is equal\nto the allocated memory.\n+optional",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreSignalCondition": {
        "description": "SignalCondition represents a dependency on an signal.",
        "properties": {
          "output_variable_name": {
            "description": "The variable name for the signal value in this nodes outputs.",
            "type": "string"
          },
          "signal_id": {
            "description": "A unique identifier for the requested signal.",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/coreLiteralType"
          }
        },
        "type": "object"
      },
      "coreSimpleType": {
        "default": "NONE",
        "description": "Define a set of simple types.",
        "enum": [
          "NONE",
          "INTEGER",
          "FLOAT",
          "STRING",
          "BOOLEAN",
          "DATETIME",
          "DURATION",
          "BINARY",
          "ERROR",
          "STRUCT"
        ],
        "type": "string"
      },
      "coreSleepCondition": {
        "description": "SleepCondition represents a dependency on waiting for the specified duration.",
        "properties": {
          "duration": {
            "description": "The overall duration for this sleep.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreSpan": {
        "description": "Span represents a duration trace of Flyte execution. The id field denotes a Flyte execution entity or an operation\nwhich uniquely identifies the Span. The spans attribute allows this Span to be further broken down into more\nprecise definitions.",
        "properties": {
          "end_time": {
            "description": "end_time defines the instance this span completed.",
            "format": "date-time",
            "type": "string"
          },
          "node_id": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "operation_id": {
            "description": "operation_id is the id of a unique operation that this Span represents.",
            "type": "string"
          },
          "spans": {
            "description": "spans defines a collection of Spans that breakdown this execution.",
            "items": {
              "$ref": "#/components/schemas/coreSpan"
            },
            "type": "array"
          },
          "start_time": {
            "description": "start_time defines the instance this span began.",
            "format": "date-time",
            "type": "string"
          },
          "task_id": {
            "$ref": "#/components/schemas/coreTaskExecutionIdentifier"
          },
          "workflow_id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          }
        },
        "type": "object"
      },
      "coreSql": {
        "description": "Sql represents a generic sql workload with a statement and dialect.",
        "properties": {
          "dialect": {
            "$ref": "#/components/schemas/SqlDialect"
          },
          "statement": {
            "title": "The actual query to run, the query can have templated parameters.\nWe use Flyte's Golang templating format for Query templating.\nFor example,\ninsert overwrite directory '{{ .rawOutputDataPrefix }}' stored as parquet\nselect *\nfrom my_table\nwhere ds = '{{ .Inputs.ds }}'",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreStructuredDataset": {
        "properties": {
          "metadata": {
            "$ref": "#/components/schemas/coreStructuredDatasetMetadata"
          },
          "uri": {
            "title": "String location uniquely identifying where the data is.\nShould start with the storage location (e.g. s3://, gs://, bq://, etc.)",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreStructuredDatasetMetadata": {
        "properties": {
          "structured_dataset_type": {
            "$ref": "#/components/schemas/coreStructuredDatasetType"
          }
        },
        "type": "object"
      },
      "coreStructuredDatasetType": {
        "properties": {
          "columns": {
            "description": "A list of ordered columns this schema comprises of.",
            "items": {
              "$ref": "#/components/schemas/StructuredDatasetTypeDatasetColumn"
            },
            "type": "array"
          },
          "external_schema_bytes": {
            "description": "The serialized bytes of a third-party schema library like Arrow.\nThis is an optional field that will not be used for type checking.",
            "format": "byte",
            "type": "string"
          },
          "external_schema_type": {
            "description": "This is a string representing the type that the bytes in external_schema_bytes are formatted in.\nThis is an optional field that will not be used for type checking.",
            "type": "string"
          },
          "format": {
            "description": "This is the storage format, the format of the bits at rest\nparquet, feather, csv, etc.\nFor two types to be compatible, the format will need to be an exact match.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreTaskExecutionIdentifier": {
        "description": "Encapsulation of fields that identify a Flyte task execution entity.",
        "properties": {
          "node_execution_id": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "retry_attempt": {
            "format": "int64",
            "type": "integer"
          },
          "task_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "coreTaskExecutionPhase": {
        "default": "UNDEFINED",
        "enum": [
          "UNDEFINED",
          "QUEUED",
          "RUNNING",
          "SUCCEEDED",
          "ABORTED",
          "FAILED",
          "INITIALIZING",
          "WAITING_FOR_RESOURCES",
          "RETRYABLE_FAILED"
        ],
        "title": "- INITIALIZING: To indicate cases where task is initializing, like: ErrImagePull, ContainerCreating, PodInitializing\n - WAITING_FOR_RESOURCES: To address cases, where underlying resource is not available: Backoff error, Resource quota exceeded",
        "type": "string"
      },
      "coreTaskLog": {
        "properties": {
          "HideOnceFinished": {
            "type": "boolean"
          },
          "ShowWhilePending": {
            "type": "boolean"
          },
          "message_format": {
            "$ref": "#/components/schemas/TaskLogMessageFormat"
          },
          "name": {
            "type": "string"
          },
          "ttl": {
            "type": "string"
          },
          "uri": {
            "type": "string"
          }
        },
        "title": "Log information for the task that is specific to a log sink\nWhen our log story is flushed out, we may have more metadata here like log link expiry",
        "type": "object"
      },
      "coreTaskMetadata": {
        "properties": {
          "cache_ignore_input_vars": {
            "description": "cache_ignore_input_vars is the input variables that should not be included when calculating hash for cache.",
            "items": {
              "type": "string"
            },
            "type": "array"
          },
          "cache_serializable": {
            "title": "Indicates whether the system should attempt to execute discoverable instances in serial to avoid duplicate work",
            "type": "boolean"
          },
          "deprecated_error_message": {
            "description": "If set, this indicates that this task is deprecated.  This will enable owners of tasks to notify consumers\nof the ending of support for a given task.",
            "type": "string"
          },
          "discoverable": {
            "description": "Indicates whether the system should attempt to lookup this task's output to avoid duplication of work.",
            "type": "boolean"
          },
          "discovery_version": {
            "description": "Indicates a logical version to apply to this task for the purpose of discovery.",
            "type": "string"
          },
          "generates_deck": {
            "description": "Indicates whether the task will generate a deck when it finishes executing.\nThe BoolValue can have three states:\n- nil: The value is not set.\n- true: The task will generate a deck.\n- false: The task will not generate a deck.",
            "type": "boolean"
          },
          "interruptible": {
            "type": "boolean"
          },
          "is_eager": {
            "description": "is_eager indicates whether the task is eager or not.\nThis would be used by CreateTask endpoint.",
            "type": "boolean"
          },
          "metadata": {
            "$ref": "#/components/schemas/coreK8sObjectMetadata"
          },
          "pod_template_name": {
            "description": "pod_template_name is the unique name of a PodTemplate k8s resource to be used as the base configuration if this\ntask creates a k8s Pod. If this value is set, the specified PodTemplate will be used instead of, but applied\nidentically as, the default PodTemplate configured in FlytePropeller.",
            "type": "string"
          },
          "retries": {
            "$ref": "#/components/schemas/coreRetryStrategy"
          },
          "runtime": {
            "$ref": "#/components/schemas/coreRuntimeMetadata"
          },
          "tags": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Arbitrary tags that allow users and the platform to store small but arbitrary labels",
            "type": "object"
          },
          "timeout": {
            "description": "The overall timeout of a task including user-triggered retries.",
            "type": "string"
          }
        },
        "title": "Task Metadata",
        "type": "object"
      },
      "coreTaskNode": {
        "description": "Refers to the task that the Node is to execute.",
        "properties": {
          "overrides": {
            "$ref": "#/components/schemas/coreTaskNodeOverrides"
          },
          "reference_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "coreTaskNodeOverrides": {
        "description": "Optional task node overrides that will be applied at task execution time.",
        "properties": {
          "container_image": {
            "description": "Override for the image used by task pods.",
            "type": "string"
          },
          "extended_resources": {
            "$ref": "#/components/schemas/coreExtendedResources"
          },
          "pod_template": {
            "$ref": "#/components/schemas/coreK8sPod"
          },
          "resources": {
            "$ref": "#/components/schemas/coreResources"
          }
        },
        "type": "object"
      },
      "coreTaskTemplate": {
        "description": "A Task structure that uniquely identifies a task in the system\nTasks are registered as a first step in the system.",
        "properties": {
          "config": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Metadata about the custom defined for this task. This is extensible to allow various plugins in the system\nto use as required.\nreserve the field numbers 1 through 15 for very frequently occurring message elements",
            "type": "object"
          },
          "container": {
            "$ref": "#/components/schemas/coreContainer"
          },
          "custom": {
            "description": "Custom data about the task. This is extensible to allow various plugins in the system.",
            "type": "object"
          },
          "extended_resources": {
            "$ref": "#/components/schemas/coreExtendedResources"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "interface": {
            "$ref": "#/components/schemas/coreTypedInterface"
          },
          "k8s_pod": {
            "$ref": "#/components/schemas/coreK8sPod"
          },
          "metadata": {
            "$ref": "#/components/schemas/coreTaskMetadata"
          },
          "security_context": {
            "$ref": "#/components/schemas/coreSecurityContext"
          },
          "sql": {
            "$ref": "#/components/schemas/coreSql"
          },
          "task_type_version": {
            "description": "This can be used to customize task handling at execution time for the same task type.",
            "format": "int32",
            "type": "integer"
          },
          "type": {
            "description": "A predefined yet extensible Task type identifier. This can be used to customize any of the components. If no\nextensions are provided in the system, Flyte will resolve the this task to its TaskCategory and default the\nimplementation registered for the TaskCategory.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreTimePartition": {
        "properties": {
          "granularity": {
            "$ref": "#/components/schemas/coreGranularity"
          },
          "value": {
            "$ref": "#/components/schemas/coreLabelValue"
          }
        },
        "type": "object"
      },
      "coreTimeTransform": {
        "properties": {
          "op": {
            "$ref": "#/components/schemas/flyteidlcoreOperator"
          },
          "transform": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreTypeAnnotation": {
        "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.",
        "properties": {
          "annotations": {
            "description": "A arbitrary JSON payload to describe a type.",
            "type": "object"
          }
        },
        "type": "object"
      },
      "coreTypeStructure": {
        "description": "Hints to improve type matching\ne.g. allows distinguishing output from custom type transformers\neven if the underlying IDL serialization matches.",
        "properties": {
          "dataclass_type": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreLiteralType"
            },
            "title": "dataclass_type only exists for dataclasses.\nThis is used to resolve the type of the fields of dataclass\nThe key is the field name, and the value is the literal type of the field\ne.g. For dataclass Foo, with fields a, and a is a string\nFoo.a will be resolved as a literal type of string from dataclass_type",
            "type": "object"
          },
          "tag": {
            "title": "Must exactly match for types to be castable",
            "type": "string"
          }
        },
        "type": "object"
      },
      "coreTypedInterface": {
        "description": "Defines strongly typed inputs and outputs.",
        "properties": {
          "inputs": {
            "$ref": "#/components/schemas/coreVariableMap"
          },
          "outputs": {
            "$ref": "#/components/schemas/coreVariableMap"
          }
        },
        "type": "object"
      },
      "coreUnion": {
        "description": "The runtime representation of a tagged union value. See `UnionType` for more details.",
        "properties": {
          "type": {
            "$ref": "#/components/schemas/coreLiteralType"
          },
          "value": {
            "$ref": "#/components/schemas/coreLiteral"
          }
        },
        "type": "object"
      },
      "coreUnionInfo": {
        "properties": {
          "targetType": {
            "$ref": "#/components/schemas/coreLiteralType"
          }
        },
        "type": "object"
      },
      "coreUnionType": {
        "description": "Defines a tagged union type, also known as a variant (and formally as the sum type).\n\nA sum type S is defined by a sequence of types (A, B, C, ...), each tagged by a string tag\nA value of type S is constructed from a value of any of the variant types. The specific choice of type is recorded by\nstoring the varaint's tag with the literal value and can be examined in runtime.\n\nType S is typically written as\nS := Apple A | Banana B | Cantaloupe C | ...\n\nNotably, a nullable (optional) type is a sum type between some type X and the singleton type representing a null-value:\nOptional X := X | Null\n\nSee also: https://en.wikipedia.org/wiki/Tagged_union",
        "properties": {
          "variants": {
            "description": "Predefined set of variants in union.",
            "items": {
              "$ref": "#/components/schemas/coreLiteralType"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "coreVariable": {
        "description": "Defines a strongly typed variable.",
        "properties": {
          "artifact_partial_id": {
            "$ref": "#/components/schemas/coreArtifactID"
          },
          "artifact_tag": {
            "$ref": "#/components/schemas/coreArtifactTag"
          },
          "description": {
            "title": "+optional string describing input variable",
            "type": "string"
          },
          "type": {
            "$ref": "#/components/schemas/coreLiteralType"
          }
        },
        "type": "object"
      },
      "coreVariableMap": {
        "properties": {
          "variables": {
            "additionalProperties": {
              "$ref": "#/components/schemas/coreVariable"
            },
            "description": "Defines a map of variable names to variables.",
            "type": "object"
          }
        },
        "title": "A map of Variables",
        "type": "object"
      },
      "coreVoid": {
        "description": "Used to denote a nil/null/None assignment to a scalar value. The underlying LiteralType for Void is intentionally\nundefined since it can be assigned to a scalar of any LiteralType.",
        "type": "object"
      },
      "coreWorkflowExecutionIdentifier": {
        "properties": {
          "domain": {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "type": "string"
          },
          "name": {
            "description": "User or system provided value for the resource.",
            "type": "string"
          },
          "org": {
            "description": "Optional, org key applied to the resource.",
            "type": "string"
          },
          "project": {
            "description": "Name of the project the resource belongs to.",
            "type": "string"
          }
        },
        "title": "Encapsulation of fields that uniquely identifies a Flyte workflow execution",
        "type": "object"
      },
      "coreWorkflowExecutionPhase": {
        "default": "UNDEFINED",
        "enum": [
          "UNDEFINED",
          "QUEUED",
          "RUNNING",
          "SUCCEEDING",
          "SUCCEEDED",
          "FAILING",
          "FAILED",
          "ABORTED",
          "TIMED_OUT",
          "ABORTING"
        ],
        "type": "string"
      },
      "coreWorkflowMetadata": {
        "description": "This is workflow layer metadata. These settings are only applicable to the workflow as a whole, and do not\npercolate down to child entities (like tasks) launched by the workflow.",
        "properties": {
          "on_failure": {
            "$ref": "#/components/schemas/WorkflowMetadataOnFailurePolicy"
          },
          "quality_of_service": {
            "$ref": "#/components/schemas/coreQualityOfService"
          },
          "tags": {
            "additionalProperties": {
              "type": "string"
            },
            "title": "Arbitrary tags that allow users and the platform to store small but arbitrary labels",
            "type": "object"
          }
        },
        "type": "object"
      },
      "coreWorkflowMetadataDefaults": {
        "description": "The difference between these settings and the WorkflowMetadata ones is that these are meant to be passed down to\na workflow's underlying entities (like tasks). For instance, 'interruptible' has no meaning at the workflow layer, it\nis only relevant when a task executes. The settings here are the defaults that are passed to all nodes\nunless explicitly overridden at the node layer.\nIf you are adding a setting that applies to both the Workflow itself, and everything underneath it, it should be\nadded to both this object and the WorkflowMetadata object above.",
        "properties": {
          "interruptible": {
            "description": "Whether child nodes of the workflow are interruptible.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "coreWorkflowNode": {
        "description": "Refers to a the workflow the node is to execute.",
        "properties": {
          "launchplan_ref": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "sub_workflow_ref": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "coreWorkflowTemplate": {
        "description": "Flyte Workflow Structure that encapsulates task, branch and subworkflow nodes to form a statically analyzable,\ndirected acyclic graph.",
        "properties": {
          "failure_node": {
            "$ref": "#/components/schemas/coreNode"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "interface": {
            "$ref": "#/components/schemas/coreTypedInterface"
          },
          "metadata": {
            "$ref": "#/components/schemas/coreWorkflowMetadata"
          },
          "metadata_defaults": {
            "$ref": "#/components/schemas/coreWorkflowMetadataDefaults"
          },
          "nodes": {
            "description": "A list of nodes. In addition, 'globals' is a special reserved node id that can be used to consume workflow inputs.",
            "items": {
              "$ref": "#/components/schemas/coreNode"
            },
            "type": "array"
          },
          "outputs": {
            "description": "A list of output bindings that specify how to construct workflow outputs. Bindings can pull node outputs or\nspecify literals. All workflow outputs specified in the interface field must be bound in order for the workflow\nto be validated. A workflow has an implicit dependency on all of its nodes to execute successfully in order to\nbind final outputs.\nMost of these outputs will be Binding's with a BindingData of type OutputReference.  That is, your workflow can\njust have an output of some constant (`Output(5)`), but usually, the workflow will be pulling\noutputs from the output of a task.",
            "items": {
              "$ref": "#/components/schemas/coreBinding"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "eventEventReason": {
        "properties": {
          "occurred_at": {
            "format": "date-time",
            "title": "The time this reason occurred",
            "type": "string"
          },
          "reason": {
            "title": "An explanation for this event",
            "type": "string"
          }
        },
        "type": "object"
      },
      "eventExternalResourceInfo": {
        "description": "This message contains metadata about external resources produced or used by a specific task execution.",
        "properties": {
          "cache_status": {
            "$ref": "#/components/schemas/coreCatalogCacheStatus"
          },
          "custom_info": {
            "title": "Extensible field for custom, plugin-specific info",
            "type": "object"
          },
          "external_id": {
            "description": "Identifier for an external resource created by this task execution, for example Qubole query ID or presto query ids.",
            "type": "string"
          },
          "index": {
            "description": "A unique index for the external resource with respect to all external resources for this task. Although the\nidentifier may change between task reporting events or retries, this will remain the same to enable aggregating\ninformation from multiple reports.",
            "format": "int64",
            "type": "integer"
          },
          "log_context": {
            "$ref": "#/components/schemas/coreLogContext"
          },
          "logs": {
            "items": {
              "$ref": "#/components/schemas/coreTaskLog"
            },
            "title": "log information for the external resource execution",
            "type": "array"
          },
          "phase": {
            "$ref": "#/components/schemas/coreTaskExecutionPhase"
          },
          "retry_attempt": {
            "format": "int64",
            "title": "Retry attempt number for this external resource, ie., 2 for the second attempt",
            "type": "integer"
          },
          "workflow_node_metadata": {
            "$ref": "#/components/schemas/flyteidleventWorkflowNodeMetadata"
          }
        },
        "type": "object"
      },
      "eventNodeExecutionEvent": {
        "properties": {
          "deck_uri": {
            "title": "String location uniquely identifying where the deck HTML file is\nNativeUrl specifies the url in the format of the configured storage provider (e.g. s3://my-bucket/randomstring/suffix.tar)",
            "type": "string"
          },
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "event_version": {
            "format": "int32",
            "type": "integer"
          },
          "id": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "input_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "input_uri": {
            "type": "string"
          },
          "is_array": {
            "description": "Indicates if this node is an ArrayNode.",
            "type": "boolean"
          },
          "is_dynamic": {
            "description": "Whether this node yielded a dynamic workflow.",
            "type": "boolean"
          },
          "is_eager": {
            "description": "Whether this node launched an eager task.",
            "type": "boolean"
          },
          "is_in_dynamic_chain": {
            "description": "Tasks and subworkflows (but not launch plans) that are run within a dynamic task are effectively independent of\nthe tasks that are registered in Admin's db. Confusingly, they are often identical, but sometimes they are not\neven registered at all. Similar to the target_entity field, at the time Admin receives this event, it has no idea\nif the relevant execution entity is was registered, or dynamic. This field indicates that the target_entity ID,\nas well as task IDs in any corresponding Task Executions, should not be used to looked up the task in Admin's db.",
            "type": "boolean"
          },
          "is_parent": {
            "description": "Whether this node launched a subworkflow.",
            "type": "boolean"
          },
          "node_name": {
            "title": "Friendly readable name for the node",
            "type": "string"
          },
          "occurred_at": {
            "description": "This timestamp represents when the original event occurred, it is generated\nby the executor of the node.",
            "format": "date-time",
            "type": "string"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "output_uri": {
            "description": "URL to the output of the execution, it encodes all the information\nincluding Cloud source provider. ie., s3://...",
            "type": "string"
          },
          "parent_node_metadata": {
            "$ref": "#/components/schemas/eventParentNodeExecutionMetadata"
          },
          "parent_task_metadata": {
            "$ref": "#/components/schemas/eventParentTaskExecutionMetadata"
          },
          "phase": {
            "$ref": "#/components/schemas/coreNodeExecutionPhase"
          },
          "producer_id": {
            "title": "the id of the originator (Propeller) of the event",
            "type": "string"
          },
          "reported_at": {
            "description": "This timestamp represents the instant when the event was reported by the executing framework. For example,\nwhen first processing a node the `occurred_at` timestamp should be the instant propeller makes progress, so when\nliteral inputs are initially copied. The event however will not be sent until after the copy completes.\nExtracting both of these timestamps facilitates a more accurate portrayal of the evaluation time-series.",
            "format": "date-time",
            "type": "string"
          },
          "retry_group": {
            "title": "Retry group to indicate grouping of nodes by retries",
            "type": "string"
          },
          "spec_node_id": {
            "title": "Identifier of the node in the original workflow/graph\nThis maps to value of WorkflowTemplate.nodes[X].id",
            "type": "string"
          },
          "target_entity": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "task_node_metadata": {
            "$ref": "#/components/schemas/flyteidleventTaskNodeMetadata"
          },
          "workflow_node_metadata": {
            "$ref": "#/components/schemas/flyteidleventWorkflowNodeMetadata"
          }
        },
        "type": "object"
      },
      "eventParentNodeExecutionMetadata": {
        "properties": {
          "node_id": {
            "title": "Unique identifier of the parent node id within the execution\nThis is value of core.NodeExecutionIdentifier.node_id of the parent node",
            "type": "string"
          }
        },
        "type": "object"
      },
      "eventParentTaskExecutionMetadata": {
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreTaskExecutionIdentifier"
          }
        },
        "type": "object"
      },
      "eventResourcePoolInfo": {
        "description": "This message holds task execution metadata specific to resource allocation used to manage concurrent\nexecutions for a project namespace.",
        "properties": {
          "allocation_token": {
            "description": "Unique resource ID used to identify this execution when allocating a token.",
            "type": "string"
          },
          "namespace": {
            "description": "Namespace under which this task execution requested an allocation token.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "eventTaskExecutionEvent": {
        "description": "Plugin specific execution event information. For tasks like Python, Hive, Spark, DynamicJob.",
        "properties": {
          "custom_info": {
            "description": "Custom data that the task plugin sends back. This is extensible to allow various plugins in the system.",
            "type": "object"
          },
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "event_version": {
            "description": "The event version is used to indicate versioned changes in how data is reported using this\nproto message. For example, event_verison > 0 means that maps tasks report logs using the\nTaskExecutionMetadata ExternalResourceInfo fields for each subtask rather than the TaskLog\nin this message.",
            "format": "int32",
            "type": "integer"
          },
          "input_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "input_uri": {
            "description": "URI of the input file, it encodes all the information\nincluding Cloud source provider. ie., s3://...",
            "type": "string"
          },
          "log_context": {
            "$ref": "#/components/schemas/coreLogContext"
          },
          "logs": {
            "items": {
              "$ref": "#/components/schemas/coreTaskLog"
            },
            "title": "log information for the task execution",
            "type": "array"
          },
          "metadata": {
            "$ref": "#/components/schemas/flyteidleventTaskExecutionMetadata"
          },
          "occurred_at": {
            "description": "This timestamp represents when the original event occurred, it is generated\nby the executor of the task.",
            "format": "date-time",
            "type": "string"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "output_uri": {
            "description": "URI to the output of the execution, it will be in a format that encodes all the information\nincluding Cloud source provider. ie., s3://...",
            "type": "string"
          },
          "parent_node_execution_id": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "phase": {
            "$ref": "#/components/schemas/coreTaskExecutionPhase"
          },
          "phase_version": {
            "description": "Some phases, like RUNNING, can send multiple events with changed metadata (new logs, additional custom_info, etc)\nthat should be recorded regardless of the lack of phase change.\nThe version field should be incremented when metadata changes across the duration of an individual phase.",
            "format": "int64",
            "type": "integer"
          },
          "producer_id": {
            "title": "id of the process that sent this event, mainly for trace debugging",
            "type": "string"
          },
          "reason": {
            "description": "An optional explanation for the phase transition.\nDeprecated: Use reasons instead.",
            "type": "string"
          },
          "reasons": {
            "description": "An optional list of explanations for the phase transition.",
            "items": {
              "$ref": "#/components/schemas/eventEventReason"
            },
            "type": "array"
          },
          "reported_at": {
            "description": "This timestamp represents the instant when the event was reported by the executing framework. For example, a k8s\npod task may be marked completed at (ie. `occurred_at`) the instant the container running user code completes,\nbut this event will not be reported until the pod is marked as completed. Extracting both of these timestamps\nfacilitates a more accurate portrayal of the evaluation time-series.",
            "format": "date-time",
            "type": "string"
          },
          "retry_attempt": {
            "format": "int64",
            "title": "retry attempt number for this task, ie., 2 for the second attempt",
            "type": "integer"
          },
          "task_id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "task_type": {
            "description": "A predefined yet extensible Task type identifier. If the task definition is already registered in flyte admin\nthis type will be identical, but not all task executions necessarily use pre-registered definitions and this\ntype is useful to render the task in the UI, filter task executions, etc.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "eventWorkflowExecutionEvent": {
        "properties": {
          "error": {
            "$ref": "#/components/schemas/coreExecutionError"
          },
          "execution_id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          },
          "occurred_at": {
            "description": "This timestamp represents when the original event occurred, it is generated\nby the executor of the workflow.",
            "format": "date-time",
            "type": "string"
          },
          "output_data": {
            "$ref": "#/components/schemas/coreLiteralMap"
          },
          "output_uri": {
            "description": "URL to the output of the execution, it encodes all the information\nincluding Cloud source provider. ie., s3://...",
            "type": "string"
          },
          "phase": {
            "$ref": "#/components/schemas/coreWorkflowExecutionPhase"
          },
          "producer_id": {
            "title": "the id of the originator (Propeller) of the event",
            "type": "string"
          }
        },
        "type": "object"
      },
      "flyteidladminDynamicWorkflowNodeMetadata": {
        "description": "For dynamic workflow nodes we capture information about the dynamic workflow definition that gets generated.",
        "properties": {
          "compiled_workflow": {
            "$ref": "#/components/schemas/coreCompiledWorkflowClosure"
          },
          "dynamic_job_spec_uri": {
            "description": "dynamic_job_spec_uri is the location of the DynamicJobSpec proto message for this DynamicWorkflow. This is\nrequired to correctly recover partially completed executions where the subworkflow has already been compiled.",
            "type": "string"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "flyteidladminNodeExecution": {
        "description": "Encapsulates all details for a single node execution entity.\nA node represents a component in the overall workflow graph. A node launch a task, multiple tasks, an entire nested\nsub-workflow, or even a separate child-workflow execution.\nThe same task can be called repeatedly in a single workflow but each node is unique.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/adminNodeExecutionClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreNodeExecutionIdentifier"
          },
          "input_uri": {
            "description": "Path to remote data store where input blob is stored.",
            "type": "string"
          },
          "metadata": {
            "$ref": "#/components/schemas/adminNodeExecutionMetaData"
          }
        },
        "type": "object"
      },
      "flyteidladminTaskCreateRequest": {
        "properties": {
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          },
          "spec": {
            "$ref": "#/components/schemas/adminTaskSpec"
          }
        },
        "title": "Represents a request structure to create a revision of a task.\nSee Task for more details",
        "type": "object"
      },
      "flyteidladminTaskCreateResponse": {
        "description": "Represents a response structure if task creation succeeds.\n\nPurposefully empty, may be populated in the future.",
        "type": "object"
      },
      "flyteidladminTaskExecution": {
        "description": "Encapsulates all details for a single task execution entity.\nA task execution represents an instantiated task, including all inputs and additional\nmetadata as well as computed results included state, outputs, and duration-based attributes.",
        "properties": {
          "closure": {
            "$ref": "#/components/schemas/adminTaskExecutionClosure"
          },
          "id": {
            "$ref": "#/components/schemas/coreTaskExecutionIdentifier"
          },
          "input_uri": {
            "description": "Path to remote data store where input blob is stored.",
            "type": "string"
          },
          "is_parent": {
            "description": "Whether this task spawned nodes.",
            "type": "boolean"
          }
        },
        "type": "object"
      },
      "flyteidladminTaskNodeMetadata": {
        "properties": {
          "cache_status": {
            "$ref": "#/components/schemas/coreCatalogCacheStatus"
          },
          "catalog_key": {
            "$ref": "#/components/schemas/coreCatalogMetadata"
          },
          "checkpoint_uri": {
            "title": "The latest checkpoint location",
            "type": "string"
          }
        },
        "title": "Metadata for the case in which the node is a TaskNode",
        "type": "object"
      },
      "flyteidladminWorkflowClosure": {
        "description": "A container holding the compiled workflow produced from the WorkflowSpec and additional metadata.",
        "properties": {
          "compiled_workflow": {
            "$ref": "#/components/schemas/coreCompiledWorkflowClosure"
          },
          "created_at": {
            "description": "Time at which the workflow was created.",
            "format": "date-time",
            "type": "string"
          }
        },
        "type": "object"
      },
      "flyteidladminWorkflowNodeMetadata": {
        "properties": {
          "executionId": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          }
        },
        "title": "Metadata for a WorkflowNode",
        "type": "object"
      },
      "flyteidlcoreEnumType": {
        "description": "Enables declaring enum types, with predefined string values\nFor len(values) > 0, the first value in the ordered list is regarded as the default value. If you wish\nTo provide no defaults, make the first value as undefined.",
        "properties": {
          "values": {
            "description": "Predefined set of enum values.",
            "items": {
              "type": "string"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "flyteidlcoreKeyValuePair": {
        "description": "A generic key value pair.",
        "properties": {
          "key": {
            "description": "required.",
            "type": "string"
          },
          "value": {
            "description": "+optional.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "flyteidlcoreOperator": {
        "default": "MINUS",
        "enum": [
          "MINUS",
          "PLUS"
        ],
        "type": "string"
      },
      "flyteidlcoreSchema": {
        "description": "A strongly typed schema that defines the interface of data retrieved from the underlying storage medium.",
        "properties": {
          "type": {
            "$ref": "#/components/schemas/coreSchemaType"
          },
          "uri": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "flyteidleventDynamicWorkflowNodeMetadata": {
        "description": "For dynamic workflow nodes we send information about the dynamic workflow definition that gets generated.",
        "properties": {
          "compiled_workflow": {
            "$ref": "#/components/schemas/coreCompiledWorkflowClosure"
          },
          "dynamic_job_spec_uri": {
            "description": "dynamic_job_spec_uri is the location of the DynamicJobSpec proto message for this DynamicWorkflow. This is\nrequired to correctly recover partially completed executions where the workflow has already been compiled.",
            "type": "string"
          },
          "id": {
            "$ref": "#/components/schemas/coreIdentifier"
          }
        },
        "type": "object"
      },
      "flyteidleventTaskExecutionMetadata": {
        "description": "Holds metadata around how a task was executed.\nAs a task transitions across event phases during execution some attributes, such its generated name, generated external resources,\nand more may grow in size but not change necessarily based on the phase transition that sparked the event update.\nMetadata is a container for these attributes across the task execution lifecycle.",
        "properties": {
          "external_resources": {
            "description": "Additional data on external resources on other back-ends or platforms (e.g. Hive, Qubole, etc) launched by this task execution.",
            "items": {
              "$ref": "#/components/schemas/eventExternalResourceInfo"
            },
            "type": "array"
          },
          "generated_name": {
            "description": "Unique, generated name for this task execution used by the backend.",
            "type": "string"
          },
          "instance_class": {
            "$ref": "#/components/schemas/TaskExecutionMetadataInstanceClass"
          },
          "plugin_identifier": {
            "description": "The identifier of the plugin used to execute this task.",
            "type": "string"
          },
          "resource_pool_info": {
            "description": "Includes additional data on concurrent resource management used during execution..\nThis is a repeated field because a plugin can request multiple resource allocations during execution.",
            "items": {
              "$ref": "#/components/schemas/eventResourcePoolInfo"
            },
            "type": "array"
          }
        },
        "type": "object"
      },
      "flyteidleventTaskNodeMetadata": {
        "properties": {
          "cache_status": {
            "$ref": "#/components/schemas/coreCatalogCacheStatus"
          },
          "catalog_key": {
            "$ref": "#/components/schemas/coreCatalogMetadata"
          },
          "checkpoint_uri": {
            "title": "The latest checkpoint location",
            "type": "string"
          },
          "dynamic_workflow": {
            "$ref": "#/components/schemas/flyteidleventDynamicWorkflowNodeMetadata"
          },
          "reservation_status": {
            "$ref": "#/components/schemas/coreCatalogReservationStatus"
          }
        },
        "type": "object"
      },
      "flyteidleventWorkflowNodeMetadata": {
        "properties": {
          "execution_id": {
            "$ref": "#/components/schemas/coreWorkflowExecutionIdentifier"
          }
        },
        "title": "For Workflow Nodes we need to send information about the workflow that's launched",
        "type": "object"
      },
      "googlerpcStatus": {
        "properties": {
          "code": {
            "format": "int32",
            "type": "integer"
          },
          "details": {
            "items": {
              "$ref": "#/components/schemas/protobufAny"
            },
            "type": "array"
          },
          "message": {
            "type": "string"
          }
        },
        "type": "object"
      },
      "protobufAny": {
        "additionalProperties": {},
        "description": "`Any` contains an arbitrary serialized protocol buffer message along with a\nURL that describes the type of the serialized message.\n\nProtobuf library provides support to pack/unpack Any values in the form\nof utility functions or additional generated methods of the Any type.\n\nExample 1: Pack and unpack a message in C++.\n\n    Foo foo = ...;\n    Any any;\n    any.PackFrom(foo);\n    ...\n    if (any.UnpackTo(&foo)) {\n      ...\n    }\n\nExample 2: Pack and unpack a message in Java.\n\n    Foo foo = ...;\n    Any any = Any.pack(foo);\n    ...\n    if (any.is(Foo.class)) {\n      foo = any.unpack(Foo.class);\n    }\n    // or ...\n    if (any.isSameTypeAs(Foo.getDefaultInstance())) {\n      foo = any.unpack(Foo.getDefaultInstance());\n    }\n\n Example 3: Pack and unpack a message in Python.\n\n    foo = Foo(...)\n    any = Any()\n    any.Pack(foo)\n    ...\n    if any.Is(Foo.DESCRIPTOR):\n      any.Unpack(foo)\n      ...\n\n Example 4: Pack and unpack a message in Go\n\n     foo := &pb.Foo{...}\n     any, err := anypb.New(foo)\n     if err != nil {\n       ...\n     }\n     ...\n     foo := &pb.Foo{}\n     if err := any.UnmarshalTo(foo); err != nil {\n       ...\n     }\n\nThe pack methods provided by protobuf library will by default use\n'type.googleapis.com/full.type.name' as the type URL and the unpack\nmethods only use the fully qualified type name after the last '/'\nin the type URL, for example \"foo.bar.com/x/y.z\" will yield type\nname \"y.z\".\n\nJSON\n====\nThe JSON representation of an `Any` value uses the regular\nrepresentation of the deserialized, embedded message, with an\nadditional field `@type` which contains the type URL. Example:\n\n    package google.profile;\n    message Person {\n      string first_name = 1;\n      string last_name = 2;\n    }\n\n    {\n      \"@type\": \"type.googleapis.com/google.profile.Person\",\n      \"firstName\": <string>,\n      \"lastName\": <string>\n    }\n\nIf the embedded message type is well-known and has a custom JSON\nrepresentation, that representation will be embedded adding a field\n`value` which holds the custom JSON in addition to the `@type`\nfield. Example (for message [google.protobuf.Duration][]):\n\n    {\n      \"@type\": \"type.googleapis.com/google.protobuf.Duration\",\n      \"value\": \"1.212s\"\n    }",
        "properties": {
          "@type": {
            "description": "A URL/resource name that uniquely identifies the type of the serialized\nprotocol buffer message. This string must contain at least\none \"/\" character. The last segment of the URL's path must represent\nthe fully qualified name of the type (as in\n`path/google.protobuf.Duration`). The name should be in a canonical form\n(e.g., leading \".\" is not accepted).\n\nIn practice, teams usually precompile into the binary all types that they\nexpect it to use in the context of Any. However, for URLs which use the\nscheme `http`, `https`, or no scheme, one can optionally set up a type\nserver that maps type URLs to message definitions as follows:\n\n* If no scheme is provided, `https` is assumed.\n* An HTTP GET on the URL must yield a [google.protobuf.Type][]\n  value in binary format, or produce an error.\n* Applications are allowed to cache lookup results based on the\n  URL, or have them precompiled into a binary to avoid any\n  lookup. Therefore, binary compatibility needs to be preserved\n  on changes to types. (Use versioned type names to manage\n  breaking changes.)\n\nNote: this functionality is not currently available in the official\nprotobuf release, and it is not used for type URLs beginning with\ntype.googleapis.com. As of May 2023, there are no widely used type server\nimplementations and no plans to implement one.\n\nSchemes other than `http`, `https` (or the empty scheme) might be\nused with implementation specific semantics.",
            "type": "string"
          }
        },
        "type": "object"
      },
      "protobufNullValue": {
        "default": "NULL_VALUE",
        "description": "`NullValue` is a singleton enumeration to represent the null value for the\n`Value` type union.\n\nThe JSON representation for `NullValue` is JSON `null`.\n\n - NULL_VALUE: Null value.",
        "enum": [
          "NULL_VALUE"
        ],
        "type": "string"
      }
    }
  },
  "info": {
    "description": "Reference for the upstream Flyte control plane API, which backs Domino Flows.",
    "title": "Flyte native API",
    "version": "version not set"
  },
  "openapi": "3.0.3",
  "paths": {
    "/api/v1/active_launch_plans/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Retrieve the active launch plan version specified by input request filters.",
        "operationId": "AdminService_GetActiveLaunchPlan",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlan"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch the active version of a LaunchPlan.",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/active_launch_plans/{project}/{domain}": {
      "get": {
        "description": "Fetch the active launch plan versions specified by input request filters.",
        "operationId": "AdminService_ListActiveLaunchPlans",
        "parameters": [
          {
            "description": "Name of the project that contains the identifiers.\n+required.",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the identifiers belongs to within the project.\n+required.",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required.",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlanList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "List active versions of LaunchPlan.",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/children/task_executions/{task_execution_id.node_execution_id.execution_id.project}/{task_execution_id.node_execution_id.execution_id.domain}/{task_execution_id.node_execution_id.execution_id.name}/{task_execution_id.node_execution_id.node_id}/{task_execution_id.task_id.project}/{task_execution_id.task_id.domain}/{task_execution_id.task_id.name}/{task_execution_id.task_id.version}/{task_execution_id.retry_attempt}": {
      "get": {
        "operationId": "AdminService_ListNodeExecutionsForTask",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "task_execution_id.node_execution_id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "task_execution_id.node_execution_id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "task_execution_id.node_execution_id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "task_execution_id.node_execution_id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "task_execution_id.task_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "task_execution_id.task_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "task_execution_id.task_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "task_execution_id.task_id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "task_execution_id.retry_attempt",
            "required": true,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "task_execution_id.task_id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "task_execution_id.task_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "task_execution_id.node_execution_id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the, server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNodeExecutionList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of NodeExecution launched by the reference TaskExecution.",
        "tags": [
          "Children"
        ]
      }
    },
    "/api/v1/data/executions/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "operationId": "AdminService_GetExecutionData",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowExecutionGetDataResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches input and output data for a Execution.",
        "tags": [
          "Data"
        ]
      }
    },
    "/api/v1/data/node_executions/{id.execution_id.project}/{id.execution_id.domain}/{id.execution_id.name}/{id.node_id}": {
      "get": {
        "operationId": "AdminService_GetNodeExecutionData",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNodeExecutionGetDataResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches input and output data for a NodeExecution.",
        "tags": [
          "Data"
        ]
      }
    },
    "/api/v1/data/task_executions/{id.node_execution_id.execution_id.project}/{id.node_execution_id.execution_id.domain}/{id.node_execution_id.execution_id.name}/{id.node_execution_id.node_id}/{id.task_id.project}/{id.task_id.domain}/{id.task_id.name}/{id.task_id.version}/{id.retry_attempt}": {
      "get": {
        "description": "Retrieve input and output data from an existing task execution.",
        "operationId": "AdminService_GetTaskExecutionData",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.node_execution_id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.task_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.task_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.task_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.task_id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.retry_attempt",
            "required": true,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "id.task_id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.task_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.node_execution_id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTaskExecutionGetDataResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches input and output data for a TaskExecution.",
        "tags": [
          "Data"
        ]
      }
    },
    "/api/v1/description_entities/{id.resource_type}/{id.project}/{id.domain}/{id.name}/{id.version}": {
      "get": {
        "description": "Retrieve an existing description entity description.",
        "operationId": "AdminService_GetDescriptionEntity",
        "parameters": [
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.",
            "in": "path",
            "name": "id.resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminDescriptionEntity"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a DescriptionEntity object.",
        "tags": [
          "Description entities"
        ]
      }
    },
    "/api/v1/description_entities/{resource_type}/{id.project}/{id.domain}": {
      "get": {
        "description": "Fetch existing description entity definitions matching input filters.",
        "operationId": "AdminService_ListDescriptionEntities2",
        "parameters": [
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.",
            "in": "path",
            "name": "resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "query",
            "name": "id.name",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminDescriptionEntityList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of DescriptionEntity definitions.",
        "tags": [
          "Description entities"
        ]
      }
    },
    "/api/v1/description_entities/{resource_type}/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Fetch existing description entity definitions matching input filters.",
        "operationId": "AdminService_ListDescriptionEntities",
        "parameters": [
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.",
            "in": "path",
            "name": "resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminDescriptionEntityList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of DescriptionEntity definitions (by name)",
        "tags": [
          "Description entities"
        ]
      }
    },
    "/api/v1/domains": {
      "get": {
        "operationId": "AdminService_GetDomains",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminGetDomainsResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Get domains",
        "tags": [
          "Domains"
        ]
      }
    },
    "/api/v1/events/nodes": {
      "post": {
        "description": "Create a node execution event recording a phase transition.",
        "operationId": "AdminService_CreateNodeEvent",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminNodeExecutionEventRequest"
              }
            }
          },
          "description": "Request to send a notification that a node execution event has occurred.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNodeExecutionEventResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Indicates a NodeExecutionEvent has occurred.",
        "tags": [
          "Events"
        ]
      }
    },
    "/api/v1/events/tasks": {
      "post": {
        "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": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTaskExecutionEventResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Indicates a TaskExecutionEvent has occurred.",
        "tags": [
          "Events"
        ]
      }
    },
    "/api/v1/events/workflows": {
      "post": {
        "description": "Create a workflow execution event recording a phase transition.",
        "operationId": "AdminService_CreateWorkflowEvent",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminWorkflowExecutionEventRequest"
              }
            }
          },
          "description": "Request to send a notification that a workflow execution event has occurred.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowExecutionEventResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Indicates a WorkflowExecutionEvent has occurred.",
        "tags": [
          "Events"
        ]
      }
    },
    "/api/v1/executions": {
      "post": {
        "description": "Create a workflow execution.",
        "operationId": "AdminService_CreateExecution",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminExecutionCreateRequest"
              }
            }
          },
          "description": "Request to launch an execution with the given project, domain and optionally-assigned name.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Triggers the creation of a Execution",
        "tags": [
          "Executions"
        ]
      }
    },
    "/api/v1/executions/recover": {
      "post": {
        "description": "Recreates a previously-run workflow execution that will only start executing from the last known failure point. In Recover mode, users cannot change any input parameters or update the version of the execution. This is extremely useful to recover from system errors and byzantine faults like - Loss of K8s cluster, bugs in platform or instability, machine failures, downstream system failures (downstream services), or simply to recover executions that failed because of retry exhaustion and should complete if tried again.",
        "operationId": "AdminService_RecoverExecution",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminExecutionRecoverRequest"
              }
            }
          },
          "description": "Request to recover the referenced execution.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Recreates a previously-run workflow execution that will only start executing from the last known",
        "tags": [
          "Executions"
        ]
      }
    },
    "/api/v1/executions/relaunch": {
      "post": {
        "description": "Relaunch a workflow execution.",
        "operationId": "AdminService_RelaunchExecution",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminExecutionRelaunchRequest"
              }
            }
          },
          "description": "Request to relaunch the referenced execution.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Triggers the creation of an identical Execution",
        "tags": [
          "Executions"
        ]
      }
    },
    "/api/v1/executions/{id.project}/{id.domain}": {
      "get": {
        "operationId": "AdminService_ListExecutions",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "query",
            "name": "id.name",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of Execution.",
        "tags": [
          "Executions"
        ]
      }
    },
    "/api/v1/executions/{id.project}/{id.domain}/{id.name}": {
      "delete": {
        "operationId": "AdminService_TerminateExecution",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceTerminateExecutionBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionTerminateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Terminates an in-progress Execution.",
        "tags": [
          "Executions"
        ]
      },
      "get": {
        "description": "Retrieve an existing workflow execution.",
        "operationId": "AdminService_GetExecution",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecution"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a Execution.",
        "tags": [
          "Executions"
        ]
      },
      "put": {
        "operationId": "AdminService_UpdateExecution",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateExecutionBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminExecutionUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Update execution belonging to project domain Execution.",
        "tags": [
          "Executions"
        ]
      }
    },
    "/api/v1/launch_plan_ids/{project}/{domain}": {
      "get": {
        "description": "Fetch existing launch plan definition identifiers matching input filters.",
        "operationId": "AdminService_ListLaunchPlanIds",
        "parameters": [
          {
            "description": "Name of the project that contains the identifiers.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the identifiers belongs to within the project.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntityIdentifierList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of NamedEntityIdentifier of launch plan objects.",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/launch_plans": {
      "post": {
        "description": "Create and register a launch plan definition.",
        "operationId": "AdminService_CreateLaunchPlan",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminLaunchPlanCreateRequest"
              }
            }
          },
          "description": "Request to register a launch plan. The included LaunchPlanSpec may have a complete or incomplete set of inputs required\nto launch a workflow execution. By default all launch plans are registered in state INACTIVE. If you wish to\nset the state to ACTIVE, you must submit a LaunchPlanUpdateRequest, after you have successfully created a launch plan.",
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlanCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for bad request that may have failed validation."
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for a request that references an identical entity that has already been registered."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Create and upload a LaunchPlan definition",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/launch_plans/{id.project}/{id.domain}": {
      "get": {
        "description": "Fetch existing launch plan definitions matching input filters.",
        "operationId": "AdminService_ListLaunchPlans2",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "query",
            "name": "id.name",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlanList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of LaunchPlan definitions.",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/launch_plans/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Fetch existing launch plan definitions matching input filters.",
        "operationId": "AdminService_ListLaunchPlans",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlanList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of LaunchPlan definitions (by name)",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/launch_plans/{id.project}/{id.domain}/{id.name}/{id.version}": {
      "get": {
        "description": "Retrieve an existing launch plan definition.",
        "operationId": "AdminService_GetLaunchPlan",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlan"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a LaunchPlan definition.",
        "tags": [
          "Launch plans"
        ]
      },
      "put": {
        "description": "Update the status of an existing launch plan definition. At most one launch plan version for a given {project, domain, name} can be active at a time. If this call sets a launch plan to active and existing version is already active, the result of this call will be that the formerly active launch plan will be made inactive and specified launch plan in this request will be made active. In the event that the formerly active launch plan had a schedule associated it with it, this schedule will be disabled. If the reference launch plan in this request is being set to active and has a schedule associated with it, the schedule will be enabled.",
        "operationId": "AdminService_UpdateLaunchPlan",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateLaunchPlanBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminLaunchPlanUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Updates the status of a registered LaunchPlan.",
        "tags": [
          "Launch plans"
        ]
      }
    },
    "/api/v1/matchable_attributes": {
      "get": {
        "description": "Retrieve a list of MatchableAttributesConfiguration objects.",
        "operationId": "AdminService_ListMatchableAttributes",
        "parameters": [
          {
            "description": "+required\n\n - TASK_RESOURCE: Applies to customizable task resource requests and limits.\n - CLUSTER_RESOURCE: Applies to configuring templated kubernetes cluster resources.\n - EXECUTION_QUEUE: Configures task and dynamic task execution queue assignment.\n - EXECUTION_CLUSTER_LABEL: Configures the K8s cluster label to be used for execution to be run\n - QUALITY_OF_SERVICE_SPECIFICATION: Configures default quality of service when undefined in an execution spec.\n - PLUGIN_OVERRIDE: Selects configurable plugin implementation behavior for a given task type.\n - WORKFLOW_EXECUTION_CONFIG: Adds defaults for customizable workflow-execution specifications and overrides.\n - CLUSTER_ASSIGNMENT: Controls how to select an available cluster on which this execution should run.",
            "in": "query",
            "name": "resource_type",
            "required": false,
            "schema": {
              "default": "TASK_RESOURCE",
              "enum": [
                "TASK_RESOURCE",
                "CLUSTER_RESOURCE",
                "EXECUTION_QUEUE",
                "EXECUTION_CLUSTER_LABEL",
                "QUALITY_OF_SERVICE_SPECIFICATION",
                "PLUGIN_OVERRIDE",
                "WORKFLOW_EXECUTION_CONFIG",
                "CLUSTER_ASSIGNMENT"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org filter applied to list project requests.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminListMatchableAttributesResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Lists custom MatchableAttributesConfiguration for a specific resource type.",
        "tags": [
          "Matchable attributes"
        ]
      }
    },
    "/api/v1/metrics/executions/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Retrieve metrics from an existing workflow execution.",
        "operationId": "AdminService_GetExecutionMetrics",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "depth defines the number of Flyte entity levels to traverse when breaking down execution details.",
            "in": "query",
            "name": "depth",
            "required": false,
            "schema": {
              "format": "int32",
              "type": "integer"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowExecutionGetMetricsResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches runtime metrics for a Execution.",
        "tags": [
          "Metrics"
        ]
      }
    },
    "/api/v1/named_entities/{resource_type}/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Retrieve a NamedEntity object.",
        "operationId": "AdminService_GetNamedEntity",
        "parameters": [
          {
            "description": "Resource type of the metadata to get. One of Task, Workflow or LaunchPlan.\n+required",
            "in": "path",
            "name": "resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntity"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Returns a NamedEntity object.",
        "tags": [
          "Named entities"
        ]
      },
      "put": {
        "description": "Update the fields associated with a NamedEntity",
        "operationId": "AdminService_UpdateNamedEntity",
        "parameters": [
          {
            "description": "Resource type of the metadata to update\n+required",
            "in": "path",
            "name": "resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateNamedEntityBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntityUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Updates a NamedEntity object.",
        "tags": [
          "Named entities"
        ]
      }
    },
    "/api/v1/named_entities/{resource_type}/{project}/{domain}": {
      "get": {
        "description": "Retrieve a list of NamedEntity objects sharing a common resource type, project, and domain.",
        "operationId": "AdminService_ListNamedEntities",
        "parameters": [
          {
            "description": "Resource type of the metadata to query. One of Task, Workflow or LaunchPlan.\n+required",
            "in": "path",
            "name": "resource_type",
            "required": true,
            "schema": {
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Name of the project that contains the identifiers.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the identifiers belongs to within the project.",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntityList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Returns a list of NamedEntity objects.",
        "tags": [
          "Named entities"
        ]
      }
    },
    "/api/v1/node_executions/{id.execution_id.project}/{id.execution_id.domain}/{id.execution_id.name}/{id.node_id}": {
      "get": {
        "operationId": "AdminService_GetNodeExecution",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/flyteidladminNodeExecution"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a NodeExecution.",
        "tags": [
          "Node executions"
        ]
      }
    },
    "/api/v1/node_executions/{id.execution_id.project}/{id.execution_id.domain}/{id.execution_id.name}/{id.node_id}/dynamic_workflow": {
      "get": {
        "operationId": "AdminService_GetDynamicNodeWorkflow",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminDynamicNodeWorkflowResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a DynamicNodeWorkflowResponse.",
        "tags": [
          "Node executions"
        ]
      }
    },
    "/api/v1/node_executions/{workflow_execution_id.project}/{workflow_execution_id.domain}/{workflow_execution_id.name}": {
      "get": {
        "operationId": "AdminService_ListNodeExecutions",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "workflow_execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "workflow_execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "workflow_execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "workflow_execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Unique identifier of the parent node in the execution\n+optional",
            "in": "query",
            "name": "unique_parent_id",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNodeExecutionList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of NodeExecution.",
        "tags": [
          "Node executions"
        ]
      }
    },
    "/api/v1/project_attributes/{attributes.project}": {
      "put": {
        "description": "Update the customized resource attributes associated with a project",
        "operationId": "AdminService_UpdateProjectAttributes",
        "parameters": [
          {
            "description": "Unique project id for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateProjectAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectAttributesUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Creates or updates custom MatchableAttributesConfiguration at the project level",
        "tags": [
          "Project attributes"
        ]
      }
    },
    "/api/v1/project_attributes/{project}": {
      "delete": {
        "description": "Delete the customized resource attributes associated with a project",
        "operationId": "AdminService_DeleteProjectAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceDeleteProjectAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectAttributesDeleteResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Deletes custom MatchableAttributesConfiguration for a project and domain.",
        "tags": [
          "Project attributes"
        ]
      },
      "get": {
        "description": "Retrieve the customized resource attributes associated with a project",
        "operationId": "AdminService_GetProjectAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Which type of matchable attributes to return.\n+required\n\n - TASK_RESOURCE: Applies to customizable task resource requests and limits.\n - CLUSTER_RESOURCE: Applies to configuring templated kubernetes cluster resources.\n - EXECUTION_QUEUE: Configures task and dynamic task execution queue assignment.\n - EXECUTION_CLUSTER_LABEL: Configures the K8s cluster label to be used for execution to be run\n - QUALITY_OF_SERVICE_SPECIFICATION: Configures default quality of service when undefined in an execution spec.\n - PLUGIN_OVERRIDE: Selects configurable plugin implementation behavior for a given task type.\n - WORKFLOW_EXECUTION_CONFIG: Adds defaults for customizable workflow-execution specifications and overrides.\n - CLUSTER_ASSIGNMENT: Controls how to select an available cluster on which this execution should run.",
            "in": "query",
            "name": "resource_type",
            "required": false,
            "schema": {
              "default": "TASK_RESOURCE",
              "enum": [
                "TASK_RESOURCE",
                "CLUSTER_RESOURCE",
                "EXECUTION_QUEUE",
                "EXECUTION_CLUSTER_LABEL",
                "QUALITY_OF_SERVICE_SPECIFICATION",
                "PLUGIN_OVERRIDE",
                "WORKFLOW_EXECUTION_CONFIG",
                "CLUSTER_ASSIGNMENT"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the project.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectAttributesGetResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches custom MatchableAttributesConfiguration for a project and domain.",
        "tags": [
          "Project attributes"
        ]
      }
    },
    "/api/v1/project_domain_attributes/{attributes.project}/{attributes.domain}": {
      "put": {
        "description": "Update the customized resource attributes associated with a project-domain combination",
        "operationId": "AdminService_UpdateProjectDomainAttributes",
        "parameters": [
          {
            "description": "Unique project id for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateProjectDomainAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectDomainAttributesUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Creates or updates custom MatchableAttributesConfiguration for a project and domain.",
        "tags": [
          "Project domain attributes"
        ]
      }
    },
    "/api/v1/project_domain_attributes/{project}/{domain}": {
      "delete": {
        "description": "Delete the customized resource attributes associated with a project-domain combination",
        "operationId": "AdminService_DeleteProjectDomainAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id which this set of attributes references.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceDeleteProjectDomainAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectDomainAttributesDeleteResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Deletes custom MatchableAttributesConfiguration for a project and domain.",
        "tags": [
          "Project domain attributes"
        ]
      },
      "get": {
        "description": "Retrieve the customized resource attributes associated with a project-domain combination",
        "operationId": "AdminService_GetProjectDomainAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id which this set of attributes references.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Which type of matchable attributes to return.\n+required\n\n - TASK_RESOURCE: Applies to customizable task resource requests and limits.\n - CLUSTER_RESOURCE: Applies to configuring templated kubernetes cluster resources.\n - EXECUTION_QUEUE: Configures task and dynamic task execution queue assignment.\n - EXECUTION_CLUSTER_LABEL: Configures the K8s cluster label to be used for execution to be run\n - QUALITY_OF_SERVICE_SPECIFICATION: Configures default quality of service when undefined in an execution spec.\n - PLUGIN_OVERRIDE: Selects configurable plugin implementation behavior for a given task type.\n - WORKFLOW_EXECUTION_CONFIG: Adds defaults for customizable workflow-execution specifications and overrides.\n - CLUSTER_ASSIGNMENT: Controls how to select an available cluster on which this execution should run.",
            "in": "query",
            "name": "resource_type",
            "required": false,
            "schema": {
              "default": "TASK_RESOURCE",
              "enum": [
                "TASK_RESOURCE",
                "CLUSTER_RESOURCE",
                "EXECUTION_QUEUE",
                "EXECUTION_CLUSTER_LABEL",
                "QUALITY_OF_SERVICE_SPECIFICATION",
                "PLUGIN_OVERRIDE",
                "WORKFLOW_EXECUTION_CONFIG",
                "CLUSTER_ASSIGNMENT"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the attributes.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectDomainAttributesGetResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches custom MatchableAttributesConfiguration for a project and domain.",
        "tags": [
          "Project domain attributes"
        ]
      }
    },
    "/api/v1/projects": {
      "get": {
        "description": "Fetch registered projects.",
        "operationId": "AdminService_ListProjects",
        "parameters": [
          {
            "description": "Indicates the number of projects to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org filter applied to list project requests.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjects"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a list of Project",
        "tags": [
          "Projects"
        ]
      },
      "post": {
        "operationId": "AdminService_RegisterProject",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminProjectRegisterRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectRegisterResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Registers a Project with the Flyte deployment.",
        "tags": [
          "Projects"
        ]
      }
    },
    "/api/v1/projects/{id}": {
      "get": {
        "description": "Fetch a registered project.",
        "operationId": "AdminService_GetProject",
        "parameters": [
          {
            "description": "Indicates a unique project.\n+required",
            "in": "path",
            "name": "id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProject"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a Project",
        "tags": [
          "Projects"
        ]
      },
      "put": {
        "description": "Update a project.",
        "operationId": "AdminService_UpdateProject",
        "parameters": [
          {
            "description": "Globally unique project name.",
            "in": "path",
            "name": "id",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateProjectBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminProjectUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Updates an existing Project",
        "tags": [
          "Projects"
        ]
      }
    },
    "/api/v1/task_executions/{id.node_execution_id.execution_id.project}/{id.node_execution_id.execution_id.domain}/{id.node_execution_id.execution_id.name}/{id.node_execution_id.node_id}/{id.task_id.project}/{id.task_id.domain}/{id.task_id.name}/{id.task_id.version}/{id.retry_attempt}": {
      "get": {
        "description": "Retrieve an existing task execution.",
        "operationId": "AdminService_GetTaskExecution",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "id.node_execution_id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.node_execution_id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.task_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.task_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.task_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.task_id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "id.retry_attempt",
            "required": true,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "id.task_id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.task_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.node_execution_id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/flyteidladminTaskExecution"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a TaskExecution.",
        "tags": [
          "Task executions"
        ]
      }
    },
    "/api/v1/task_executions/{node_execution_id.execution_id.project}/{node_execution_id.execution_id.domain}/{node_execution_id.execution_id.name}/{node_execution_id.node_id}": {
      "get": {
        "description": "Fetch existing task executions matching input filters.",
        "operationId": "AdminService_ListTaskExecutions",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "node_execution_id.execution_id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "node_execution_id.execution_id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User or system provided value for the resource.",
            "in": "path",
            "name": "node_execution_id.execution_id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "in": "path",
            "name": "node_execution_id.node_id",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "node_execution_id.execution_id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTaskExecutionList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches a list of TaskExecution.",
        "tags": [
          "Task executions"
        ]
      }
    },
    "/api/v1/task_ids/{project}/{domain}": {
      "get": {
        "description": "Fetch existing task definition identifiers matching input filters.",
        "operationId": "AdminService_ListTaskIds",
        "parameters": [
          {
            "description": "Name of the project that contains the identifiers.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the identifiers belongs to within the project.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntityIdentifierList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of NamedEntityIdentifier of task objects.",
        "tags": [
          "Tasks"
        ]
      }
    },
    "/api/v1/tasks": {
      "post": {
        "description": "Create and register a task definition.",
        "operationId": "AdminService_CreateTask",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/flyteidladminTaskCreateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/flyteidladminTaskCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for bad request that may have failed validation."
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for a request that references an identical entity that has already been registered."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Create and upload a Task definition",
        "tags": [
          "Tasks"
        ]
      }
    },
    "/api/v1/tasks/{id.project}/{id.domain}": {
      "get": {
        "description": "Fetch existing task definitions matching input filters.",
        "operationId": "AdminService_ListTasks2",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "query",
            "name": "id.name",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTaskList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of Task definitions.",
        "tags": [
          "Tasks"
        ]
      }
    },
    "/api/v1/tasks/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Fetch existing task definitions matching input filters.",
        "operationId": "AdminService_ListTasks",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTaskList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of Task definitions (by name)",
        "tags": [
          "Tasks"
        ]
      }
    },
    "/api/v1/tasks/{id.project}/{id.domain}/{id.name}/{id.version}": {
      "get": {
        "description": "Retrieve an existing task definition.",
        "operationId": "AdminService_GetTask",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminTask"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a Task definition.",
        "tags": [
          "Tasks"
        ]
      }
    },
    "/api/v1/version": {
      "get": {
        "description": "Retrieve the Version (including the Build  information) for FlyteAdmin service",
        "operationId": "AdminService_GetVersion",
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminGetVersionResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Get version",
        "tags": [
          "Version"
        ]
      }
    },
    "/api/v1/workflow_attributes/{attributes.project}/{attributes.domain}/{attributes.workflow}": {
      "put": {
        "description": "Update the customized resource attributes associated with a project, domain and workflow combination",
        "operationId": "AdminService_UpdateWorkflowAttributes",
        "parameters": [
          {
            "description": "Unique project id for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Workflow name for which this set of attributes will be applied.",
            "in": "path",
            "name": "attributes.workflow",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceUpdateWorkflowAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowAttributesUpdateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Creates or updates custom MatchableAttributesConfiguration for a project, domain and workflow.",
        "tags": [
          "Workflow attributes"
        ]
      }
    },
    "/api/v1/workflow_attributes/{project}/{domain}/{workflow}": {
      "delete": {
        "description": "Delete the customized resource attributes associated with a project, domain and workflow combination",
        "operationId": "AdminService_DeleteWorkflowAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id which this set of attributes references.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Workflow name which this set of attributes references.\n+required",
            "in": "path",
            "name": "workflow",
            "required": true,
            "schema": {
              "type": "string"
            }
          }
        ],
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/AdminServiceDeleteWorkflowAttributesBody"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowAttributesDeleteResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Deletes custom MatchableAttributesConfiguration for a project, domain and workflow.",
        "tags": [
          "Workflow attributes"
        ]
      },
      "get": {
        "description": "Retrieve the customized resource attributes associated with a project, domain and workflow combination",
        "operationId": "AdminService_GetWorkflowAttributes",
        "parameters": [
          {
            "description": "Unique project id which this set of attributes references.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Unique domain id which this set of attributes references.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Workflow name which this set of attributes references.\n+required",
            "in": "path",
            "name": "workflow",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Which type of matchable attributes to return.\n+required\n\n - TASK_RESOURCE: Applies to customizable task resource requests and limits.\n - CLUSTER_RESOURCE: Applies to configuring templated kubernetes cluster resources.\n - EXECUTION_QUEUE: Configures task and dynamic task execution queue assignment.\n - EXECUTION_CLUSTER_LABEL: Configures the K8s cluster label to be used for execution to be run\n - QUALITY_OF_SERVICE_SPECIFICATION: Configures default quality of service when undefined in an execution spec.\n - PLUGIN_OVERRIDE: Selects configurable plugin implementation behavior for a given task type.\n - WORKFLOW_EXECUTION_CONFIG: Adds defaults for customizable workflow-execution specifications and overrides.\n - CLUSTER_ASSIGNMENT: Controls how to select an available cluster on which this execution should run.",
            "in": "query",
            "name": "resource_type",
            "required": false,
            "schema": {
              "default": "TASK_RESOURCE",
              "enum": [
                "TASK_RESOURCE",
                "CLUSTER_RESOURCE",
                "EXECUTION_QUEUE",
                "EXECUTION_CLUSTER_LABEL",
                "QUALITY_OF_SERVICE_SPECIFICATION",
                "PLUGIN_OVERRIDE",
                "WORKFLOW_EXECUTION_CONFIG",
                "CLUSTER_ASSIGNMENT"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the attributes.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowAttributesGetResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetches custom MatchableAttributesConfiguration for a project, domain and workflow.",
        "tags": [
          "Workflow attributes"
        ]
      }
    },
    "/api/v1/workflow_ids/{project}/{domain}": {
      "get": {
        "operationId": "AdminService_ListWorkflowIds",
        "parameters": [
          {
            "description": "Name of the project that contains the identifiers.\n+required",
            "in": "path",
            "name": "project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the identifiers belongs to within the project.\n+required",
            "in": "path",
            "name": "domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, the server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminNamedEntityIdentifierList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of NamedEntityIdentifier of workflow objects.",
        "tags": [
          "Workflows"
        ]
      }
    },
    "/api/v1/workflows": {
      "post": {
        "description": "Create and register a workflow definition.",
        "operationId": "AdminService_CreateWorkflow",
        "requestBody": {
          "content": {
            "application/json": {
              "schema": {
                "$ref": "#/components/schemas/adminWorkflowCreateRequest"
              }
            }
          },
          "required": true
        },
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowCreateResponse"
                }
              }
            },
            "description": "A successful response."
          },
          "400": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for bad request that may have failed validation."
          },
          "409": {
            "content": {
              "application/json": {
                "schema": {}
              }
            },
            "description": "Returned for a request that references an identical entity that has already been registered."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Create and upload a Workflow definition",
        "tags": [
          "Workflows"
        ]
      }
    },
    "/api/v1/workflows/{id.project}/{id.domain}": {
      "get": {
        "description": "Fetch existing workflow definitions matching input filters.",
        "operationId": "AdminService_ListWorkflows2",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "query",
            "name": "id.name",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of Workflow definitions.",
        "tags": [
          "Workflows"
        ]
      }
    },
    "/api/v1/workflows/{id.project}/{id.domain}/{id.name}": {
      "get": {
        "description": "Fetch existing workflow definitions matching input filters.",
        "operationId": "AdminService_ListWorkflows",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.\nThe combination of project + domain + name uniquely identifies the resource.\n+optional - in certain contexts - like 'List API', 'Launch plans'",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the number of resources to be returned.\n+required",
            "in": "query",
            "name": "limit",
            "required": false,
            "schema": {
              "format": "int64",
              "type": "integer"
            }
          },
          {
            "description": "In the case of multiple pages of results, this server-provided token can be used to fetch the next page\nin a query.\n+optional",
            "in": "query",
            "name": "token",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates a list of filters passed as string.\nMore info on constructing filters : <Link>\n+optional",
            "in": "query",
            "name": "filters",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates an attribute to sort the response values.\n+required",
            "in": "query",
            "name": "sort_by.key",
            "required": false,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Indicates the direction to apply sort key for response values.\n+optional\n\n - DESCENDING: By default, fields are sorted in descending order.",
            "in": "query",
            "name": "sort_by.direction",
            "required": false,
            "schema": {
              "default": "DESCENDING",
              "enum": [
                "DESCENDING",
                "ASCENDING"
              ],
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflowList"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a list of Workflow definitions (by name)",
        "tags": [
          "Workflows"
        ]
      }
    },
    "/api/v1/workflows/{id.project}/{id.domain}/{id.name}/{id.version}": {
      "get": {
        "description": "Retrieve an existing workflow definition.",
        "operationId": "AdminService_GetWorkflow",
        "parameters": [
          {
            "description": "Name of the project the resource belongs to.",
            "in": "path",
            "name": "id.project",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Name of the domain the resource belongs to.\nA domain can be considered as a subset within a specific project.",
            "in": "path",
            "name": "id.domain",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "User provided value for the resource.",
            "in": "path",
            "name": "id.name",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Specific version of the resource.",
            "in": "path",
            "name": "id.version",
            "required": true,
            "schema": {
              "type": "string"
            }
          },
          {
            "description": "Identifies the specific type of resource that this identifier corresponds to.\n\n - 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.\nEventually 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 \nin a similar manner to other Flyte objects",
            "in": "query",
            "name": "id.resource_type",
            "required": false,
            "schema": {
              "default": "UNSPECIFIED",
              "enum": [
                "UNSPECIFIED",
                "TASK",
                "WORKFLOW",
                "LAUNCH_PLAN",
                "DATASET"
              ],
              "type": "string"
            }
          },
          {
            "description": "Optional, org key applied to the resource.",
            "in": "query",
            "name": "id.org",
            "required": false,
            "schema": {
              "type": "string"
            }
          }
        ],
        "responses": {
          "200": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/adminWorkflow"
                }
              }
            },
            "description": "A successful response."
          },
          "default": {
            "content": {
              "application/json": {
                "schema": {
                  "$ref": "#/components/schemas/googlerpcStatus"
                }
              }
            },
            "description": "An unexpected error response."
          }
        },
        "summary": "Fetch a Workflow definition.",
        "tags": [
          "Workflows"
        ]
      }
    }
  },
  "servers": [
    {
      "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.",
      "url": "https://mycluster.domino.tech/flows"
    }
  ],
  "tags": [
    {
      "name": "Children"
    },
    {
      "name": "Data"
    },
    {
      "name": "Description entities"
    },
    {
      "name": "Domains"
    },
    {
      "name": "Events"
    },
    {
      "name": "Executions"
    },
    {
      "name": "Launch plans"
    },
    {
      "name": "Matchable attributes"
    },
    {
      "name": "Metrics"
    },
    {
      "name": "Named entities"
    },
    {
      "name": "Node executions"
    },
    {
      "name": "Project attributes"
    },
    {
      "name": "Project domain attributes"
    },
    {
      "name": "Projects"
    },
    {
      "name": "Task executions"
    },
    {
      "name": "Tasks"
    },
    {
      "name": "Version"
    },
    {
      "name": "Workflow attributes"
    },
    {
      "name": "Workflows"
    }
  ]
}
