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

# Create and upload a :ref:`ref_flyteidl.admin.LaunchPlan` definition

> Create and register a launch plan definition.



## OpenAPI

````yaml /api-specs/cloud/flyte-native-api.yaml post /api/v1/launch_plans
openapi: 3.0.0
info:
  title: flyteidl/service/admin.proto
  version: version not set
servers:
  - url: https://mycluster.domino.tech
    description: >-
      Replace 'mycluster.domino.tech' with your Domino cluster hostname. For
      Domino Cloud customers, that is <your-subdomain>.domino.tech (e.g.,
      acme.domino.tech). For self-hosted deployments, it is the hostname you
      reach the Domino UI at.
security: []
tags:
  - name: AdminService
paths:
  /api/v1/launch_plans:
    post:
      tags:
        - AdminService
      summary: Create and upload a :ref:`ref_flyteidl.admin.LaunchPlan` definition
      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

          to launch a workflow execution. By default all launch plans are
          registered in state INACTIVE. If you wish to

          set the state to ACTIVE, you must submit a LaunchPlanUpdateRequest,
          after you have successfully created a launch plan.
        required: true
      responses:
        '200':
          description: A successful response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/adminLaunchPlanCreateResponse'
        '400':
          description: Returned for bad request that may have failed validation.
          content:
            application/json:
              schema: {}
        '409':
          description: >-
            Returned for a request that references an identical entity that has
            already been registered.
          content:
            application/json:
              schema: {}
        default:
          description: An unexpected error response.
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/googlerpcStatus'
components:
  schemas:
    adminLaunchPlanCreateRequest:
      type: object
      properties:
        id:
          $ref: '#/components/schemas/coreIdentifier'
        spec:
          $ref: '#/components/schemas/adminLaunchPlanSpec'
      description: >-
        Request to register a launch plan. The included LaunchPlanSpec may have
        a complete or incomplete set of inputs required

        to launch a workflow execution. By default all launch plans are
        registered in state INACTIVE. If you wish to

        set the state to ACTIVE, you must submit a LaunchPlanUpdateRequest,
        after you have successfully created a launch plan.
    adminLaunchPlanCreateResponse:
      type: object
      description: Purposefully empty, may be populated in the future.
    googlerpcStatus:
      type: object
      properties:
        code:
          type: integer
          format: int32
        message:
          type: string
        details:
          type: array
          items:
            $ref: '#/components/schemas/protobufAny'
    coreIdentifier:
      type: object
      properties:
        resource_type:
          $ref: '#/components/schemas/coreResourceType'
        project:
          type: string
          description: Name of the project the resource belongs to.
        domain:
          type: string
          description: |-
            Name of the domain the resource belongs to.
            A domain can be considered as a subset within a specific project.
        name:
          type: string
          description: User provided value for the resource.
        version:
          type: string
          description: Specific version of the resource.
        org:
          type: string
          description: Optional, org key applied to the resource.
      description: Encapsulation of fields that uniquely identifies a Flyte resource.
    adminLaunchPlanSpec:
      type: object
      properties:
        workflow_id:
          $ref: '#/components/schemas/coreIdentifier'
        entity_metadata:
          $ref: '#/components/schemas/adminLaunchPlanMetadata'
        default_inputs:
          $ref: '#/components/schemas/coreParameterMap'
        fixed_inputs:
          $ref: '#/components/schemas/coreLiteralMap'
        role:
          type: string
          title: >-
            String to indicate the role to use to execute the workflow
            underneath
        labels:
          $ref: '#/components/schemas/adminLabels'
        annotations:
          $ref: '#/components/schemas/adminAnnotations'
        auth:
          $ref: '#/components/schemas/adminAuth'
        auth_role:
          $ref: '#/components/schemas/adminAuthRole'
        security_context:
          $ref: '#/components/schemas/coreSecurityContext'
        quality_of_service:
          $ref: '#/components/schemas/coreQualityOfService'
        raw_output_data_config:
          $ref: '#/components/schemas/adminRawOutputDataConfig'
        max_parallelism:
          type: integer
          format: int32
          description: >-
            Controls the maximum number of tasknodes that can be run in parallel
            for the entire workflow.

            This is useful to achieve fairness. Note: MapTasks are regarded as
            one unit,

            and parallelism/concurrency of MapTasks is independent from this.
        interruptible:
          type: boolean
          description: >-
            Allows for the interruptible flag of a workflow to be overwritten
            for a single execution.

            Omitting this field uses the workflow's value as a default.

            As we need to distinguish between the field not being provided and
            its default value false, we have to use a wrapper

            around the bool field.
        overwrite_cache:
          type: boolean
          description: >-
            Allows for all cached values of a workflow and its tasks to be
            overwritten for a single execution.

            If enabled, all calculations are performed even if cached results
            would be available, overwriting the stored

            data once execution finishes successfully.
        envs:
          $ref: '#/components/schemas/adminEnvs'
        execution_env_assignments:
          type: array
          items:
            $ref: '#/components/schemas/coreExecutionEnvAssignment'
          description: Execution environment assignments to be set for the execution.
        cluster_assignment:
          $ref: '#/components/schemas/adminClusterAssignment'
        concurrency_policy:
          $ref: '#/components/schemas/adminConcurrencyPolicy'
      description: User-provided launch plan definition and configuration values.
    protobufAny:
      type: object
      properties:
        '@type':
          type: string
          description: >-
            A URL/resource name that uniquely identifies the type of the
            serialized

            protocol buffer message. This string must contain at least

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

            the fully qualified name of the type (as in

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

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


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

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

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

            server that maps type URLs to message definitions as follows:


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

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

            Note: this functionality is not currently available in the official

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

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

            implementations and no plans to implement one.


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

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

        URL that describes the type of the serialized message.


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

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


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

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

        Example 2: Pack and unpack a message in Java.

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

         Example 3: Pack and unpack a message in Python.

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

         Example 4: Pack and unpack a message in Go

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

        The pack methods provided by protobuf library will by default use

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

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

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

        name "y.z".


        JSON

        ====

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

        representation of the deserialized, embedded message, with an

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

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

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

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

        representation, that representation will be embedded adding a field

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

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

            {
              "@type": "type.googleapis.com/google.protobuf.Duration",
              "value": "1.212s"
            }
    coreResourceType:
      type: string
      enum:
        - UNSPECIFIED
        - TASK
        - WORKFLOW
        - LAUNCH_PLAN
        - DATASET
      default: UNSPECIFIED
      description: >-
        Indicates a resource type within Flyte.

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

        in a similar manner to other Flyte objects
    adminLaunchPlanMetadata:
      type: object
      properties:
        schedule:
          $ref: '#/components/schemas/adminSchedule'
        notifications:
          type: array
          items:
            $ref: '#/components/schemas/adminNotification'
          title: List of notifications based on Execution status transitions
        launch_conditions:
          $ref: '#/components/schemas/protobufAny'
      description: >-
        Additional launch plan attributes included in the LaunchPlanSpec not
        strictly required to launch

        the reference workflow.
    coreParameterMap:
      type: object
      properties:
        parameters:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/coreParameter'
          description: Defines a map of parameter names to parameters.
      description: A map of Parameters.
    coreLiteralMap:
      type: object
      properties:
        literals:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/coreLiteral'
      description: >-
        A map of literals. This is a workaround since oneofs in proto messages
        cannot contain a repeated field.
    adminLabels:
      type: object
      properties:
        values:
          type: object
          additionalProperties:
            type: string
          description: Map of custom labels to be applied to the execution resource.
      description: >-
        Label values to be applied to an execution resource.

        In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined

        to specify how to merge labels defined at registration and execution
        time.
    adminAnnotations:
      type: object
      properties:
        values:
          type: object
          additionalProperties:
            type: string
          description: Map of custom annotations to be applied to the execution resource.
      description: >-
        Annotation values to be applied to an execution resource.

        In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined

        to specify how to merge annotations defined at registration and
        execution time.
    adminAuth:
      type: object
      properties:
        assumable_iam_role:
          type: string
          description: >-
            Defines an optional iam role which will be used for tasks run in
            executions created with this launch plan.
        kubernetes_service_account:
          type: string
          description: >-
            Defines an optional kubernetes service account which will be used
            for tasks run in executions created with this launch plan.
      description: >-
        Defines permissions associated with executions created by this launch
        plan spec.

        Use either of these roles when they have permissions required by your
        workflow execution.

        Deprecated.
    adminAuthRole:
      type: object
      properties:
        assumable_iam_role:
          type: string
          description: >-
            Defines an optional iam role which will be used for tasks run in
            executions created with this launch plan.
        kubernetes_service_account:
          type: string
          description: >-
            Defines an optional kubernetes service account which will be used
            for tasks run in executions created with this launch plan.
      description: >-
        Defines permissions associated with executions created by this launch
        plan spec.

        Use either of these roles when they have permissions required by your
        workflow execution.

        Deprecated.
    coreSecurityContext:
      type: object
      properties:
        run_as:
          $ref: '#/components/schemas/coreIdentity'
        secrets:
          type: array
          items:
            $ref: '#/components/schemas/coreSecret'
          description: >-
            secrets indicate the list of secrets the task needs in order to
            proceed. Secrets will be mounted/passed to the

            pod as it starts. If the plugin responsible for kicking of the task
            will not run it on a flyte cluster (e.g. AWS

            Batch), it's the responsibility of the plugin to fetch the secret
            (which means propeller identity will need access

            to the secret) and to pass it to the remote execution engine.
        tokens:
          type: array
          items:
            $ref: '#/components/schemas/coreOAuth2TokenRequest'
          description: >-
            tokens indicate the list of token requests the task needs in order
            to proceed. Tokens will be mounted/passed to the

            pod as it starts. If the plugin responsible for kicking of the task
            will not run it on a flyte cluster (e.g. AWS

            Batch), it's the responsibility of the plugin to fetch the secret
            (which means propeller identity will need access

            to the secret) and to pass it to the remote execution engine.
      description: SecurityContext holds security attributes that apply to tasks.
    coreQualityOfService:
      type: object
      properties:
        tier:
          $ref: '#/components/schemas/QualityOfServiceTier'
        spec:
          $ref: '#/components/schemas/coreQualityOfServiceSpec'
      description: Indicates the priority of an execution.
    adminRawOutputDataConfig:
      type: object
      properties:
        output_location_prefix:
          type: string
          title: |-
            Prefix for where offloaded data from user workflows will be written
            e.g. s3://bucket/key or s3://bucket/
      description: >-
        Encapsulates user settings pertaining to offloaded data (i.e. Blobs,
        Schema, query data, etc.).

        See https://github.com/flyteorg/flyte/issues/211 for more background
        information.
    adminEnvs:
      type: object
      properties:
        values:
          type: array
          items:
            $ref: '#/components/schemas/flyteidlcoreKeyValuePair'
          description: >-
            Map of custom environment variables to be applied to the execution
            resource.
      description: >-
        Environment variable values to be applied to an execution resource.

        In the future a mode (e.g. OVERRIDE, APPEND, etc) can be defined

        to specify how to merge environment variables defined at registration
        and execution time.
    coreExecutionEnvAssignment:
      type: object
      properties:
        node_ids:
          type: array
          items:
            type: string
          description: >-
            node_ids is a list of node ids that are being assigned the execution
            environment.
        task_type:
          type: string
          description: >-
            task_type is the type of task that is being assigned. This is used
            to override which Flyte

            plugin will be used during execution.
        execution_env:
          $ref: '#/components/schemas/coreExecutionEnv'
      description: >-
        ExecutionEnvAssignment is a message that is used to assign an execution
        environment to a set of

        nodes.
    adminClusterAssignment:
      type: object
      properties:
        cluster_pool_name:
          type: string
      description: >-
        Encapsulates specifications for routing an execution onto a specific
        cluster.
    adminConcurrencyPolicy:
      type: object
      properties:
        max:
          type: integer
          format: int32
          title: A setting for the maximum number of concurrent workflows
        behavior:
          $ref: '#/components/schemas/adminConcurrencyLimitBehavior'
    adminSchedule:
      type: object
      properties:
        cron_expression:
          type: string
          title: |-
            Uses AWS syntax: Minutes Hours Day-of-month Month Day-of-week Year
            e.g. for a schedule that runs every 15 minutes: 0/15 * * * ? *
        rate:
          $ref: '#/components/schemas/adminFixedRate'
        cron_schedule:
          $ref: '#/components/schemas/adminCronSchedule'
        kickoff_time_input_arg:
          type: string
          description: >-
            Name of the input variable that the kickoff time will be supplied to
            when the workflow is kicked off.
      description: >-
        Defines complete set of information required to trigger an execution on
        a schedule.
    adminNotification:
      type: object
      properties:
        phases:
          type: array
          items:
            $ref: '#/components/schemas/coreWorkflowExecutionPhase'
          title: |-
            A list of phases to which users can associate the notifications to.
            +required
        email:
          $ref: '#/components/schemas/adminEmailNotification'
        pager_duty:
          $ref: '#/components/schemas/adminPagerDutyNotification'
        slack:
          $ref: '#/components/schemas/adminSlackNotification'
      description: >-
        Represents a structure for notifications based on execution status.

        The notification content is configured within flyte admin but can be
        templatized.

        Future iterations could expose configuring notifications with custom
        content.
    coreParameter:
      type: object
      properties:
        var:
          $ref: '#/components/schemas/coreVariable'
        default:
          $ref: '#/components/schemas/coreLiteral'
        required:
          type: boolean
          description: +optional, is this value required to be filled.
        artifact_query:
          $ref: '#/components/schemas/coreArtifactQuery'
        artifact_id:
          $ref: '#/components/schemas/coreArtifactID'
      description: |-
        A parameter is used as input to a launch plan and has
        the special ability to have a default value or mark itself as required.
    coreLiteral:
      type: object
      properties:
        scalar:
          $ref: '#/components/schemas/coreScalar'
        collection:
          $ref: '#/components/schemas/coreLiteralCollection'
        map:
          $ref: '#/components/schemas/coreLiteralMap'
        offloaded_metadata:
          $ref: '#/components/schemas/coreLiteralOffloadedMetadata'
        hash:
          type: string
          title: >-
            A hash representing this literal.

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

            (https://github.com/flyteorg/flyte/blob/master/rfc/system/1893-caching-of-offloaded-objects.md)
        metadata:
          type: object
          additionalProperties:
            type: string
          description: Additional metadata for literals.
      description: >-
        A simple value. This supports any level of nesting (e.g. array of array
        of array of Blobs) as well as simple primitives.
    coreIdentity:
      type: object
      properties:
        iam_role:
          type: string
          description: >-
            iam_role references the fully qualified name of Identity & Access
            Management role to impersonate.
        k8s_service_account:
          type: string
          description: >-
            k8s_service_account references a kubernetes service account to
            impersonate.
        oauth2_client:
          $ref: '#/components/schemas/coreOAuth2Client'
        execution_identity:
          type: string
          title: execution_identity references the subject who makes the execution
      description: >-
        Identity encapsulates the various security identities a task can run as.
        It's up to the underlying plugin to pick the

        right identity for the execution environment.
    coreSecret:
      type: object
      properties:
        group:
          type: string
          title: >-
            The name of the secret group where to find the key referenced below.
            For K8s secrets, this should be the name of

            the v1/secret object. For Confidant, this should be the Credential
            name. For Vault, this should be the secret name.

            For AWS Secret Manager, this should be the name of the secret.

            +required
        group_version:
          type: string
          title: >-
            The group version to fetch. This is not supported in all secret
            management systems. It'll be ignored for the ones

            that do not support it.

            +optional
        key:
          type: string
          title: >-
            The name of the secret to mount. This has to match an existing
            secret in the system. It's up to the implementation

            of the secret management system to require case sensitivity. For K8s
            secrets, Confidant and Vault, this should

            match one of the keys inside the secret. For AWS Secret Manager,
            it's ignored.

            +optional
        mount_requirement:
          $ref: '#/components/schemas/SecretMountType'
        env_var:
          type: string
          title: >-
            env_var is optional. Custom environment variable to set the value of
            the secret. If mount_requirement is ENV_VAR,

            then the value is the secret itself. If mount_requirement is FILE,
            then the value is the path to the secret file.

            +optional
      description: >-
        Secret encapsulates information about the secret a task needs to
        proceed. An environment variable

        FLYTE_SECRETS_ENV_PREFIX will be passed to indicate the prefix of the
        environment variables that will be present if

        secrets are passed through environment variables.

        FLYTE_SECRETS_DEFAULT_DIR will be passed to indicate the prefix of the
        path where secrets will be mounted if secrets

        are passed through file mounts.
    coreOAuth2TokenRequest:
      type: object
      properties:
        name:
          type: string
          title: >-
            name indicates a unique id for the token request within this task
            token requests. It'll be used as a suffix for

            environment variables and as a filename for mounting tokens as
            files.

            +required
        type:
          $ref: '#/components/schemas/coreOAuth2TokenRequestType'
        client:
          $ref: '#/components/schemas/coreOAuth2Client'
        idp_discovery_endpoint:
          type: string
          title: >-
            idp_discovery_endpoint references the discovery endpoint used to
            retrieve token endpoint and other related

            information.

            +optional
        token_endpoint:
          type: string
          title: >-
            token_endpoint references the token issuance endpoint. If
            idp_discovery_endpoint is not provided, this parameter is

            mandatory.

            +optional
      description: >-
        OAuth2TokenRequest encapsulates information needed to request an OAuth2
        token.

        FLYTE_TOKENS_ENV_PREFIX will be passed to indicate the prefix of the
        environment variables that will be present if

        tokens are passed through environment variables.

        FLYTE_TOKENS_PATH_PREFIX will be passed to indicate the prefix of the
        path where secrets will be mounted if tokens

        are passed through file mounts.
    QualityOfServiceTier:
      type: string
      enum:
        - UNDEFINED
        - HIGH
        - MEDIUM
        - LOW
      default: UNDEFINED
      description: ' - UNDEFINED: Default: no quality of service specified.'
    coreQualityOfServiceSpec:
      type: object
      properties:
        queueing_budget:
          type: string
          description: Indicates how much queueing delay an execution can tolerate.
      description: Represents customized execution run-time attributes.
    flyteidlcoreKeyValuePair:
      type: object
      properties:
        key:
          type: string
          description: required.
        value:
          type: string
          description: +optional.
      description: A generic key value pair.
    coreExecutionEnv:
      type: object
      properties:
        name:
          type: string
          description: >-
            name is a human-readable identifier for the execution environment.
            This is combined with the

            project, domain, and version to uniquely identify an execution
            environment.
        type:
          type: string
          description: type is the type of the execution environment.
        extant:
          type: object
          description: extant is a reference to an existing environment.
        spec:
          type: object
          description: spec is a specification of the environment.
        version:
          type: string
          description: >-
            version is the version of the execution environment. This may be
            used differently by each

            individual environment type (ex. auto-generated or manually
            provided), but is intended to

            allow variance in environment specifications with the same ID.
      description: >-
        ExecutionEnv is a message that is used to specify the execution
        environment.
    adminConcurrencyLimitBehavior:
      type: string
      enum:
        - CONCURRENCY_LIMIT_BEHAVIOR_UNSPECIFIED
        - CONCURRENCY_LIMIT_BEHAVIOR_SKIP
      default: CONCURRENCY_LIMIT_BEHAVIOR_UNSPECIFIED
      description: ' - CONCURRENCY_LIMIT_BEHAVIOR_SKIP: A workflow that will be skipped because the limit has been hit.'
    adminFixedRate:
      type: object
      properties:
        value:
          type: integer
          format: int64
        unit:
          $ref: '#/components/schemas/adminFixedRateUnit'
      description: Option for schedules run at a certain frequency e.g. every 2 minutes.
    adminCronSchedule:
      type: object
      properties:
        schedule:
          type: string
          title: >-
            Standard/default cron implementation as described by
            https://en.wikipedia.org/wiki/Cron#CRON_expression;

            Also supports nonstandard predefined scheduling definitions

            as described by
            https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/ScheduledEvents.html#CronExpressions

            except @reboot
        offset:
          type: string
          title: >-
            ISO 8601 duration as described by
            https://en.wikipedia.org/wiki/ISO_8601#Durations
      description: Options for schedules to run according to a cron expression.
    coreWorkflowExecutionPhase:
      type: string
      enum:
        - UNDEFINED
        - QUEUED
        - RUNNING
        - SUCCEEDING
        - SUCCEEDED
        - FAILING
        - FAILED
        - ABORTED
        - TIMED_OUT
        - ABORTING
      default: UNDEFINED
    adminEmailNotification:
      type: object
      properties:
        recipients_email:
          type: array
          items:
            type: string
          title: |-
            The list of email addresses recipients for this notification.
            +required
        template:
          type: string
          title: |-
            The template to use for this notification.
            +optional
      description: Defines an email notification specification.
    adminPagerDutyNotification:
      type: object
      properties:
        recipients_email:
          type: array
          items:
            type: string
          title: >-
            Currently, PagerDuty notifications leverage email to trigger a
            notification.

            +required
        template:
          type: string
          title: |-
            The template to use for this notification.
            +optional
      description: Defines a pager duty notification specification.
    adminSlackNotification:
      type: object
      properties:
        recipients_email:
          type: array
          items:
            type: string
          title: >-
            Currently, Slack notifications leverage email to trigger a
            notification.

            +required
        template:
          type: string
          title: |-
            The template to use for this notification.
            +optional
      description: Defines a slack notification specification.
    coreVariable:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/coreLiteralType'
        description:
          type: string
          title: +optional string describing input variable
        artifact_partial_id:
          $ref: '#/components/schemas/coreArtifactID'
        artifact_tag:
          $ref: '#/components/schemas/coreArtifactTag'
      description: Defines a strongly typed variable.
    coreArtifactQuery:
      type: object
      properties:
        artifact_id:
          $ref: '#/components/schemas/coreArtifactID'
        artifact_tag:
          $ref: '#/components/schemas/coreArtifactTag'
        uri:
          type: string
        binding:
          $ref: '#/components/schemas/coreArtifactBindingData'
      title: |-
        Uniqueness constraints for Artifacts
         - project, domain, name, version, partitions
        Option 2 (tags are standalone, point to an individual artifact id):
         - project, domain, name, alias (points to one partition if partitioned)
         - project, domain, name, partition key, partition value
    coreArtifactID:
      type: object
      properties:
        artifact_key:
          $ref: '#/components/schemas/coreArtifactKey'
        version:
          type: string
        partitions:
          $ref: '#/components/schemas/corePartitions'
        time_partition:
          $ref: '#/components/schemas/coreTimePartition'
    coreScalar:
      type: object
      properties:
        primitive:
          $ref: '#/components/schemas/corePrimitive'
        blob:
          $ref: '#/components/schemas/coreBlob'
        binary:
          $ref: '#/components/schemas/coreBinary'
        schema:
          $ref: '#/components/schemas/flyteidlcoreSchema'
        none_type:
          $ref: '#/components/schemas/coreVoid'
        error:
          $ref: '#/components/schemas/coreError'
        generic:
          type: object
        structured_dataset:
          $ref: '#/components/schemas/coreStructuredDataset'
        union:
          $ref: '#/components/schemas/coreUnion'
    coreLiteralCollection:
      type: object
      properties:
        literals:
          type: array
          items:
            $ref: '#/components/schemas/coreLiteral'
      description: >-
        A collection of literals. This is a workaround since oneofs in proto
        messages cannot contain a repeated field.
    coreLiteralOffloadedMetadata:
      type: object
      properties:
        uri:
          type: string
          description: The location of the offloaded core.Literal.
        size_bytes:
          type: string
          format: uint64
          description: The size of the offloaded data.
        inferred_type:
          $ref: '#/components/schemas/coreLiteralType'
      description: A message that contains the metadata of the offloaded data.
    coreOAuth2Client:
      type: object
      properties:
        client_id:
          type: string
          title: >-
            client_id is the public id for the client to use. The system will
            not perform any pre-auth validation that the

            secret requested matches the client_id indicated here.

            +required
        client_secret:
          $ref: '#/components/schemas/coreSecret'
      description: >-
        OAuth2Client encapsulates OAuth2 Client Credentials to be used when
        making calls on behalf of that task.
    SecretMountType:
      type: string
      enum:
        - ANY
        - ENV_VAR
        - FILE
      default: ANY
      description: |2-
         - ANY: Default case, indicates the client can tolerate either mounting options.
         - ENV_VAR: ENV_VAR indicates the secret needs to be mounted as an environment variable.
         - FILE: FILE indicates the secret needs to be mounted as a file.
    coreOAuth2TokenRequestType:
      type: string
      enum:
        - CLIENT_CREDENTIALS
      default: CLIENT_CREDENTIALS
      description: |-
        Type of the token requested.

         - CLIENT_CREDENTIALS: CLIENT_CREDENTIALS indicates a 2-legged OAuth token requested using client credentials.
    adminFixedRateUnit:
      type: string
      enum:
        - MINUTE
        - HOUR
        - DAY
      default: MINUTE
      description: Represents a frequency at which to run a schedule.
    coreLiteralType:
      type: object
      properties:
        simple:
          $ref: '#/components/schemas/coreSimpleType'
        schema:
          $ref: '#/components/schemas/coreSchemaType'
        collection_type:
          $ref: '#/components/schemas/coreLiteralType'
        map_value_type:
          $ref: '#/components/schemas/coreLiteralType'
        blob:
          $ref: '#/components/schemas/coreBlobType'
        enum_type:
          $ref: '#/components/schemas/flyteidlcoreEnumType'
        structured_dataset_type:
          $ref: '#/components/schemas/coreStructuredDatasetType'
        union_type:
          $ref: '#/components/schemas/coreUnionType'
        metadata:
          type: object
          description: >-
            This field contains type metadata that is descriptive of the type,
            but is NOT considered in type-checking.  This might be used by

            consumers to identify special behavior or display extended
            information for the type.
        annotation:
          $ref: '#/components/schemas/coreTypeAnnotation'
        structure:
          $ref: '#/components/schemas/coreTypeStructure'
      description: Defines a strong type to allow type checking between interfaces.
    coreArtifactTag:
      type: object
      properties:
        artifact_key:
          $ref: '#/components/schemas/coreArtifactKey'
        value:
          $ref: '#/components/schemas/coreLabelValue'
    coreArtifactBindingData:
      type: object
      properties:
        partition_key:
          type: string
        bind_to_time_partition:
          type: boolean
        time_transform:
          $ref: '#/components/schemas/coreTimeTransform'
      title: Only valid for triggers
    coreArtifactKey:
      type: object
      properties:
        project:
          type: string
          description: >-
            Project and domain and suffix needs to be unique across a given
            artifact store.
        domain:
          type: string
        name:
          type: string
        org:
          type: string
    corePartitions:
      type: object
      properties:
        value:
          type: object
          additionalProperties:
            $ref: '#/components/schemas/coreLabelValue'
    coreTimePartition:
      type: object
      properties:
        value:
          $ref: '#/components/schemas/coreLabelValue'
        granularity:
          $ref: '#/components/schemas/coreGranularity'
    corePrimitive:
      type: object
      properties:
        integer:
          type: string
          format: int64
        float_value:
          type: number
          format: double
        string_value:
          type: string
        boolean:
          type: boolean
        datetime:
          type: string
          format: date-time
        duration:
          type: string
      title: Primitive Types
    coreBlob:
      type: object
      properties:
        metadata:
          $ref: '#/components/schemas/coreBlobMetadata'
        uri:
          type: string
      description: >-
        Refers to an offloaded set of files. It encapsulates the type of the
        store and a unique uri for where the data is.

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

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

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

            Should start with the storage location (e.g. s3://, gs://, bq://,
            etc.)
        metadata:
          $ref: '#/components/schemas/coreStructuredDatasetMetadata'
    coreUnion:
      type: object
      properties:
        value:
          $ref: '#/components/schemas/coreLiteral'
        type:
          $ref: '#/components/schemas/coreLiteralType'
      description: >-
        The runtime representation of a tagged union value. See `UnionType` for
        more details.
    coreSimpleType:
      type: string
      enum:
        - NONE
        - INTEGER
        - FLOAT
        - STRING
        - BOOLEAN
        - DATETIME
        - DURATION
        - BINARY
        - ERROR
        - STRUCT
      default: NONE
      description: Define a set of simple types.
    coreSchemaType:
      type: object
      properties:
        columns:
          type: array
          items:
            $ref: '#/components/schemas/SchemaTypeSchemaColumn'
          description: A list of ordered columns this schema comprises of.
      description: >-
        Defines schema columns and types to strongly type-validate schemas
        interoperability.
    coreBlobType:
      type: object
      properties:
        format:
          type: string
          title: |-
            Format can be a free form string understood by SDK/UI etc like
            csv, parquet etc
        dimensionality:
          $ref: '#/components/schemas/BlobTypeBlobDimensionality'
      title: Defines type behavior for blob objects
    flyteidlcoreEnumType:
      type: object
      properties:
        values:
          type: array
          items:
            type: string
          description: Predefined set of enum values.
      description: >-
        Enables declaring enum types, with predefined string values

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

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

            parquet, feather, csv, etc.

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

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


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

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

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


        Type S is typically written as

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


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

        Optional X := X | Null


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

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

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

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

            Foo.a will be resolved as a literal type of string from
            dataclass_type
      description: |-
        Hints to improve type matching
        e.g. allows distinguishing output from custom type transformers
        even if the underlying IDL serialization matches.
    coreLabelValue:
      type: object
      properties:
        static_value:
          type: string
          title: The string static value is for use in the Partitions object
        time_value:
          type: string
          format: date-time
          title: The time value is for use in the TimePartition case
        triggered_binding:
          $ref: '#/components/schemas/coreArtifactBindingData'
        input_binding:
          $ref: '#/components/schemas/coreInputBindingData'
        runtime_binding:
          $ref: '#/components/schemas/coreRuntimeBinding'
    coreTimeTransform:
      type: object
      properties:
        transform:
          type: string
        op:
          $ref: '#/components/schemas/flyteidlcoreOperator'
    coreGranularity:
      type: string
      enum:
        - UNSET
        - MINUTE
        - HOUR
        - DAY
        - MONTH
      default: UNSET
      title: '- DAY: default'
    coreBlobMetadata:
      type: object
      properties:
        type:
          $ref: '#/components/schemas/coreBlobType'
    coreStructuredDatasetMetadata:
      type: object
      properties:
        structured_dataset_type:
          $ref: '#/components/schemas/coreStructuredDatasetType'
    SchemaTypeSchemaColumn:
      type: object
      properties:
        name:
          type: string
          title: A unique name -within the schema type- for the column
        type:
          $ref: '#/components/schemas/SchemaColumnSchemaColumnType'
    BlobTypeBlobDimensionality:
      type: string
      enum:
        - SINGLE
        - MULTIPART
      default: SINGLE
    StructuredDatasetTypeDatasetColumn:
      type: object
      properties:
        name:
          type: string
          description: A unique name within the schema type for the column.
        literal_type:
          $ref: '#/components/schemas/coreLiteralType'
    coreInputBindingData:
      type: object
      properties:
        var:
          type: string
    coreRuntimeBinding:
      type: object
    flyteidlcoreOperator:
      type: string
      enum:
        - MINUS
        - PLUS
      default: MINUS
    SchemaColumnSchemaColumnType:
      type: string
      enum:
        - INTEGER
        - FLOAT
        - STRING
        - BOOLEAN
        - DATETIME
        - DURATION
      default: INTEGER

````