package workflows

import "time"

#Workflow: {
	@jsonschema(schema="https://json-schema.org/draft/2020-12/schema")
	@jsonschema(id="https://raw.githubusercontent.com/argoproj/argo-workflows/HEAD/api/jsonschema/schema.json")
	matchN(1, [#."io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate" & {}, #."io.argoproj.workflow.v1alpha1.CronWorkflow" & {}, #."io.argoproj.workflow.v1alpha1.Workflow" & {}, #."io.argoproj.workflow.v1alpha1.WorkflowEventBinding" & {}, #."io.argoproj.workflow.v1alpha1.WorkflowTemplate" & {}])

	#: "eventsource.CreateEventSourceRequest": {
		"eventSource"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSource"
		"namespace"?:   string
	}

	#: "eventsource.EventSourceDeletedResponse": {}

	#: "eventsource.EventSourceWatchEvent": {
		"object"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSource"
		"type"?:   string
	}

	// structured log entry
	#: "eventsource.LogEntry": {
		// optional - the event name (e.g. `example`)
		"eventName"?:       string
		"eventSourceName"?: string

		// optional - the event source type (e.g. `webhook`)
		"eventSourceType"?: string
		"level"?:           string
		"msg"?:             string
		"namespace"?:       string
		"time"?:            #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"
	}

	#: "eventsource.UpdateEventSourceRequest": {
		"eventSource"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSource"
		"name"?:        string
		"namespace"?:   string
	}

	// AMQPConsumeConfig holds the configuration to immediately starts
	// delivering queued messages
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPConsumeConfig": {
		// AutoAck when true, the server will acknowledge deliveries to
		// this consumer prior to writing
		// the delivery to the network
		// +optional
		"autoAck"?: bool

		// ConsumerTag is the identity of the consumer included in every
		// delivery
		// +optional
		"consumerTag"?: string

		// Exclusive when true, the server will ensure that this is the
		// sole consumer from this queue
		// +optional
		"exclusive"?: bool

		// NoLocal flag is not supported by RabbitMQ
		// +optional
		"noLocal"?: bool

		// NowWait when true, do not wait for the server to confirm the
		// request and immediately begin deliveries
		// +optional
		"noWait"?: bool
	}

	// AMQPEventSource refers to an event-source for AMQP stream
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPEventSource": {
		// Auth hosts secret selectors for username and password
		// +optional
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// Backoff holds parameters applied to connection.
		// +optional
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Consume holds the configuration to immediately starts
		// delivering queued messages
		// For more information, visit
		// https://pkg.go.dev/github.com/rabbitmq/amqp091-go#Channel.Consume
		// +optional
		"consume"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPConsumeConfig"

		// ExchangeDeclare holds the configuration for the exchange on the
		// server
		// For more information, visit
		// https://pkg.go.dev/github.com/rabbitmq/amqp091-go#Channel.ExchangeDeclare
		// +optional
		"exchangeDeclare"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPExchangeDeclareConfig"

		// ExchangeName is the exchange name
		// For more information, visit
		// https://www.rabbitmq.com/tutorials/amqp-concepts.html
		"exchangeName"?: string

		// ExchangeType is rabbitmq exchange type
		"exchangeType"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// QueueBind holds the configuration that binds an exchange to a
		// queue so that publishings to the
		// exchange will be routed to the queue when the publishing
		// routing key matches the binding routing key
		// For more information, visit
		// https://pkg.go.dev/github.com/rabbitmq/amqp091-go#Channel.QueueBind
		// +optional
		"queueBind"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPQueueBindConfig"

		// QueueDeclare holds the configuration of a queue to hold
		// messages and deliver to consumers.
		// Declaring creates a queue if it doesn't already exist, or
		// ensures that an existing queue matches
		// the same parameters
		// For more information, visit
		// https://pkg.go.dev/github.com/rabbitmq/amqp091-go#Channel.QueueDeclare
		// +optional
		"queueDeclare"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPQueueDeclareConfig"

		// Routing key for bindings
		"routingKey"?: string

		// TLS configuration for the amqp client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// URL for rabbitmq service
		"url"?: string

		// URLSecret is secret reference for rabbitmq service URL
		"urlSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// AMQPExchangeDeclareConfig holds the configuration for the
	// exchange on the server
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPExchangeDeclareConfig": {
		// AutoDelete removes the exchange when no bindings are active
		// +optional
		"autoDelete"?: bool

		// Durable keeps the exchange also after the server restarts
		// +optional
		"durable"?: bool

		// Internal when true does not accept publishings
		// +optional
		"internal"?: bool

		// NowWait when true does not wait for a confirmation from the
		// server
		// +optional
		"noWait"?: bool
	}

	// AMQPQueueBindConfig holds the configuration that binds an
	// exchange to a queue so that publishings to the
	// exchange will be routed to the queue when the publishing
	// routing key matches the binding routing key
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPQueueBindConfig": {
		// NowWait false and the queue could not be bound, the channel
		// will be closed with an error
		// +optional
		"noWait"?: bool
	}

	// AMQPQueueDeclareConfig holds the configuration of a queue to
	// hold messages and deliver to consumers.
	// Declaring creates a queue if it doesn't already exist, or
	// ensures that an existing queue matches
	// the same parameters
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPQueueDeclareConfig": {
		// Arguments of a queue (also known as "x-arguments") used for
		// optional features and plugins
		// +optional
		"arguments"?: string

		// AutoDelete removes the queue when no consumers are active
		// +optional
		"autoDelete"?: bool

		// Durable keeps the queue also after the server restarts
		// +optional
		"durable"?: bool

		// Exclusive sets the queues to be accessible only by the
		// connection that declares them and will be
		// deleted wgen the connection closes
		// +optional
		"exclusive"?: bool

		// Name of the queue. If empty the server auto-generates a unique
		// name for this queue
		// +optional
		"name"?: string

		// NowWait when true, the queue assumes to be declared on the
		// server
		// +optional
		"noWait"?: bool
	}

	// AWSLambdaTrigger refers to specification of the trigger to
	// invoke an AWS Lambda function
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AWSLambdaTrigger": {
		// AccessKey refers K8s secret containing aws access key
		// +optional
		"accessKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// FunctionName refers to the name of the function to invoke.
		"functionName"?: string

		// Choose from the following options.
		//
		// * RequestResponse (default) - Invoke the function
		// synchronously. Keep
		// the connection open until the function returns a response or
		// times out.
		// The API response includes the function response and additional
		// data.
		//
		// * Event - Invoke the function asynchronously. Send events that
		// fail multiple
		// times to the function's dead-letter queue (if it's configured).
		// The API
		// response only includes a status code.
		//
		// * DryRun - Validate parameter values and verify that the user
		// or role
		// has permission to invoke the function.
		// +optional
		"invocationType"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Region is AWS region
		"region"?: string

		// RoleARN is the Amazon Resource Name (ARN) of the role to
		// assume.
		// +optional
		"roleARN"?: string

		// SecretKey refers K8s secret containing aws secret key
		// +optional
		"secretKey"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// Amount represent a numeric amount.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Amount": "value"?: string

	// ArgoWorkflowTrigger is the trigger for the Argo Workflow
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ArgoWorkflowTrigger": {
		// Args is the list of arguments to pass to the argo CLI
		"args"?: [...string]

		// Operation refers to the type of operation performed on the argo
		// workflow resource.
		// Default value is Submit.
		// +optional
		"operation"?: string

		// Parameters is the list of parameters to pass to resolved Argo
		// Workflow object
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Source of the K8s resource file(s)
		"source"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ArtifactLocation"
	}

	// ArtifactLocation describes the source location for an external
	// artifact
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ArtifactLocation": {
		// Configmap that stores the artifact
		"configmap"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// File artifact is artifact stored in a file
		"file"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.FileArtifact"

		// Git repository hosting the artifact
		"git"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitArtifact"

		// Inline artifact is embedded in sensor spec as a string
		"inline"?: string

		// Resource is generic template for K8s resource
		"resource"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.K8SResource"

		// S3 compliant artifact
		"s3"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Artifact"

		// URL to fetch the artifact from
		"url"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.URLArtifact"
	}

	// AzureEventHubsTrigger refers to specification of the Azure
	// Event Hubs Trigger
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureEventHubsTrigger": {
		// FQDN refers to the namespace dns of Azure Event Hubs to be used
		// i.e. <namespace>.servicebus.windows.net
		"fqdn"?: string

		// HubName refers to the Azure Event Hub to send events to
		"hubName"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// SharedAccessKey refers to a K8s secret containing the primary
		// key for the
		"sharedAccessKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SharedAccessKeyName refers to the name of the Shared Access Key
		"sharedAccessKeyName"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// AzureEventsHubEventSource describes the event source for azure
	// events hub
	// More info at https://docs.microsoft.com/en-us/azure/event-hubs/
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureEventsHubEventSource": {
		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// FQDN of the EventHubs namespace you created
		// More info at
		// https://docs.microsoft.com/en-us/azure/event-hubs/event-hubs-get-connection-string
		"fqdn"?: string

		// Event Hub path/name
		"hubName"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// SharedAccessKey is the generated value of the key. If both this
		// field and SharedAccessKeyName are not provided
		// it will try to access via Azure AD with DefaultAzureCredential,
		// FQDN and HubName.
		// +optional
		"sharedAccessKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SharedAccessKeyName is the name you chose for your
		// application's SAS keys. If both this field and SharedAccessKey
		// are not provided
		// it will try to access via Azure AD with DefaultAzureCredential,
		// FQDN and HubName.
		// +optional
		"sharedAccessKeyName"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// AzureQueueStorageEventSource describes the event source for
	// azure queue storage
	// more info at
	// https://learn.microsoft.com/en-us/azure/storage/queues/
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureQueueStorageEventSource": {
		// ConnectionString is the connection string to access Azure Queue
		// Storage. If this fields is not provided
		// it will try to access via Azure AD with StorageAccountName.
		// +optional
		"connectionString"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// DecodeMessage specifies if all the messages should be base64
		// decoded.
		// If set to true the decoding is done before the evaluation of
		// JSONBody
		// +optional
		"decodeMessage"?: bool

		// DLQ specifies if a dead-letter queue is configured for messages
		// that can't be processed successfully.
		// If set to true, messages with invalid payload won't be
		// acknowledged to allow to forward them farther to the
		// dead-letter queue.
		// The default value is false.
		// +optional
		"dlq"?: bool

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// QueueName is the name of the queue
		"queueName"?: string

		// StorageAccountName is the name of the storage account where the
		// queue is. This field is necessary to
		// access via Azure AD (managed identity) and it is ignored if
		// ConnectionString is set.
		// +optional
		"storageAccountName"?: string

		// WaitTimeInSeconds is the duration (in seconds) for which the
		// event source waits between empty results from the queue.
		// The default value is 3 seconds.
		// +optional
		"waitTimeInSeconds"?: int
	}

	// AzureServiceBusEventSource describes the event source for azure
	// service bus
	// More info at
	// https://docs.microsoft.com/en-us/azure/service-bus-messaging/
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureServiceBusEventSource": {
		// ConnectionString is the connection string for the Azure Service
		// Bus. If this fields is not provided
		// it will try to access via Azure AD with DefaultAzureCredential
		// and FullyQualifiedNamespace.
		// +optional
		"connectionString"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// FullyQualifiedNamespace is the Service Bus namespace name (ex:
		// myservicebus.servicebus.windows.net). This field is necessary
		// to
		// access via Azure AD (managed identity) and it is ignored if
		// ConnectionString is set.
		// +optional
		"fullyQualifiedNamespace"?: string

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// QueueName is the name of the Azure Service Bus Queue
		"queueName"?: string

		// SubscriptionName is the name of the Azure Service Bus Topic
		// Subscription
		"subscriptionName"?: string

		// TLS configuration for the service bus client
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// TopicName is the name of the Azure Service Bus Topic
		"topicName"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureServiceBusTrigger": {
		// ConnectionString is the connection string for the Azure Service
		// Bus
		"connectionString"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// QueueName is the name of the Azure Service Bus Queue
		"queueName"?: string

		// SubscriptionName is the name of the Azure Service Bus Topic
		// Subscription
		"subscriptionName"?: string

		// TLS configuration for the service bus client
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// TopicName is the name of the Azure Service Bus Topic
		"topicName"?: string
	}

	// Backoff for an operation
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff": {
		// The initial duration in nanoseconds or strings like "1s", "3m"
		// +optional
		"duration"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Int64OrString"

		// Duration is multiplied by factor each iteration
		// +optional
		"factor"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Amount"

		// The amount of jitter applied each iteration
		// +optional
		"jitter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Amount"

		// Exit with error after this many steps
		// +optional
		"steps"?: int
	}

	// BasicAuth contains the reference to K8s secrets that holds the
	// username and password
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth": {
		// Password refers to the Kubernetes secret that holds the
		// password required for basic auth.
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Username refers to the Kubernetes secret that holds the
		// username required for basic auth.
		"username"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// BitbucketAuth holds the different auth strategies for
	// connecting to Bitbucket
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketAuth": {
		// Basic is BasicAuth auth strategy.
		// +optional
		"basic"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketBasicAuth"

		// OAuthToken refers to the K8s secret that holds the OAuth Bearer
		// token.
		// +optional
		"oauthToken"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// BitbucketBasicAuth holds the information required to
	// authenticate user via basic auth mechanism
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketBasicAuth": {
		// Password refers to the K8s secret that holds the password.
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Username refers to the K8s secret that holds the username.
		"username"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// BitbucketEventSource describes the event source for Bitbucket
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketEventSource": {
		// Auth information required to connect to Bitbucket.
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketAuth"

		// DeleteHookOnFinish determines whether to delete the defined
		// Bitbucket hook once the event source is stopped.
		// +optional
		"deleteHookOnFinish"?: bool

		// Events this webhook is subscribed to.
		"events"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will be passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// DeprecatedOwner is the owner of the repository.
		// Deprecated: use Repositories instead. Will be unsupported in
		// v1.9
		// +optional
		"owner"?: string

		// DeprecatedProjectKey is the key of the project to which the
		// repository relates
		// Deprecated: use Repositories instead. Will be unsupported in
		// v1.9
		// +optional
		"projectKey"?: string

		// Repositories holds a list of repositories for which integration
		// needs to set up
		// +optional
		"repositories"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketRepository"]

		// DeprecatedRepositorySlug is a URL-friendly version of a
		// repository name, automatically generated by Bitbucket for use
		// in the URL
		// Deprecated: use Repositories instead. Will be unsupported in
		// v1.9
		// +optional
		"repositorySlug"?: string

		// Webhook refers to the configuration required to run an http
		// server
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketRepository": {
		// Owner is the owner of the repository
		"owner"?: string

		// RepositorySlug is a URL-friendly version of a repository name,
		// automatically generated by Bitbucket for use in the URL
		"repositorySlug"?: string
	}

	// BitbucketServerEventSource refers to event-source related to
	// Bitbucket Server events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketServerEventSource": {
		// AccessToken is reference to K8s secret which holds the
		// bitbucket api access information.
		// +optional
		"accessToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// BitbucketServerBaseURL is the base URL for API requests to a
		// custom endpoint.
		"bitbucketserverBaseURL"?: string

		// CheckInterval is a duration in which to wait before checking
		// that the webhooks exist, e.g. 1s, 30m, 2h... (defaults to 1m)
		// +optional
		"checkInterval"?: string

		// DeleteHookOnFinish determines whether to delete the Bitbucket
		// Server hook for the project once the event source is stopped.
		// +optional
		"deleteHookOnFinish"?: bool

		// Events are bitbucket event to listen to.
		// Refer
		// https://confluence.atlassian.com/bitbucketserver/event-payload-938025882.html
		// +optional
		"events"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// OneEventPerChange controls whether to process each change in a
		// repo:refs_changed webhook event as a separate
		// io.argoproj.workflow.v1alpha1. This setting is useful when
		// multiple tags are
		// pushed simultaneously for the same commit, and each tag needs
		// to independently trigger an action, such as a distinct
		// workflow in Argo Workflows. When enabled, the
		// BitbucketServerEventSource publishes an individual
		// BitbucketServerEventData for each change, ensuring independent
		// processing of each tag or reference update in a
		// single webhook event.
		// +optional
		"oneEventPerChange"?: bool

		// DeprecatedProjectKey is the key of project for which
		// integration needs to set up.
		// Deprecated: use Repositories instead. Will be unsupported in
		// v1.8.
		// +optional
		"projectKey"?: string

		// Projects holds a list of projects for which integration needs
		// to set up, this will add the webhook to all repositories in
		// the project.
		// +optional
		"projects"?: [...string]

		// Repositories holds a list of repositories for which integration
		// needs to set up.
		// +optional
		"repositories"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketServerRepository"]

		// DeprecatedRepositorySlug is the slug of the repository for
		// which integration needs to set up.
		// Deprecated: use Repositories instead. Will be unsupported in
		// v1.8.
		// +optional
		"repositorySlug"?: string

		// SkipBranchRefsChangedOnOpenPR bypasses the event
		// repo:refs_changed for branches whenever there's an associated
		// open pull request.
		// This helps in optimizing the event handling process by avoiding
		// unnecessary triggers for branch reference changes that are
		// already part of a pull request under review.
		// +optional
		"skipBranchRefsChangedOnOpenPR"?: bool

		// TLS configuration for the bitbucketserver client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Webhook holds configuration to run a http server.
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"

		// WebhookSecret is reference to K8s secret which holds the
		// bitbucket webhook secret (for HMAC validation).
		// +optional
		"webhookSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketServerRepository": {
		// ProjectKey is the key of project for which integration needs to
		// set up.
		"projectKey"?: string

		// RepositorySlug is the slug of the repository for which
		// integration needs to set up.
		"repositorySlug"?: string
	}

	// CalendarEventSource describes a time based dependency. One of
	// the fields (schedule, interval, or recurrence) must be passed.
	// Schedule takes precedence over interval; interval takes
	// precedence over recurrence
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CalendarEventSource": {
		// ExclusionDates defines the list of DATE-TIME exceptions for
		// recurring events.
		"exclusionDates"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Interval is a string that describes an interval duration, e.g.
		// 1s, 30m, 2h...
		// +optional
		"interval"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Persistence hold the configuration for event persistence
		"persistence"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventPersistence"

		// Schedule is a cron-like expression. For reference, see:
		// https://en.wikipedia.org/wiki/Cron
		// +optional
		"schedule"?: string

		// Timezone in which to run the schedule
		// +optional
		"timezone"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CatchupConfiguration": {
		// Enabled enables to triggered the missed schedule when
		// eventsource restarts
		"enabled"?: bool

		// MaxDuration holds max catchup duration
		"maxDuration"?: string
	}

	// Condition contains details about resource state
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Condition": {
		// Last time the condition transitioned from one status to
		// another.
		// +optional
		"lastTransitionTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// Human-readable message indicating details about last
		// transition.
		// +optional
		"message"?: string

		// Unique, this should be a short, machine understandable string
		// that gives the reason
		// for condition's last transition. For example, "ImageNotFound"
		// +optional
		"reason"?: string

		// Condition status, True, False or Unknown.
		// +required
		"status"?: string

		// Condition type.
		// +required
		"type"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConditionsResetByTime": {
		// Cron is a cron-like expression. For reference, see:
		// https://en.wikipedia.org/wiki/Cron
		"cron"?: string

		// +optional
		"timezone"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConditionsResetCriteria": {
		// Schedule is a cron-like expression. For reference, see:
		// https://en.wikipedia.org/wiki/Cron
		"byTime"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConditionsResetByTime"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConfigMapPersistence": {
		// CreateIfNotExist will create configmap if it doesn't exists
		"createIfNotExist"?: bool

		// Name of the configmap
		"name"?: string
	}

	// Container defines customized spec for a container
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Container": {
		// +optional
		"env"?: [...#."io.k8s.api.core.v1.EnvVar"]

		// +optional
		"envFrom"?: [...#."io.k8s.api.core.v1.EnvFromSource"]

		// +optional
		"imagePullPolicy"?: string

		// +optional
		"resources"?: #."io.k8s.api.core.v1.ResourceRequirements"

		// +optional
		"securityContext"?: #."io.k8s.api.core.v1.SecurityContext"

		// +optional
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]
	}

	// CustomTrigger refers to the specification of the custom
	// trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CustomTrigger": {
		// CertSecret refers to the secret that contains cert for secure
		// connection between sensor and custom trigger gRPC server.
		"certSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Parameters is the list of parameters that is applied to
		// resolved custom trigger trigger object.
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Secure refers to type of the connection between sensor to
		// custom trigger gRPC
		"secure"?: bool

		// ServerNameOverride for the secure connection between sensor and
		// custom trigger gRPC server.
		"serverNameOverride"?: string

		// ServerURL is the url of the gRPC server that executes custom
		// trigger
		"serverURL"?: string

		// Spec is the custom trigger resource specification that custom
		// trigger gRPC server knows how to interpret.
		"spec"?: {
			[string]: string
		}
	}

	// DataFilter describes constraints and filters for event data
	// Regular Expressions are purposefully not a feature as they are
	// overkill for our uses here
	// See Rob Pike's Post:
	// https://commandcenter.blogspot.com/2011/08/regular-expressions-in-lexing-and.html
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.DataFilter": {
		// Comparator compares the event data with a user given value.
		// Can be ">=", ">", "=", "!=", "<", or "<=".
		// Is optional, and if left blank treated as equality "=".
		"comparator"?: string

		// Path is the JSONPath of the event's (JSON decoded) data key
		// Path is a series of keys separated by a dot. A key may contain
		// wildcard characters '*' and '?'.
		// To access an array value use the index as the key. The dot and
		// wildcard characters can be escaped with '\\'.
		// See https://github.com/tidwall/gjson#path-syntax for more
		// information on how to use this.
		"path"?: string

		// Template is a go-template for extracting a string from the
		// event's data.
		// A Template is evaluated with provided path, type and value.
		// The templating follows the standard go-template syntax as well
		// as sprig's extra functions.
		// See https://pkg.go.dev/text/template and
		// https://masterminds.github.io/sprig/
		"template"?: string

		// Type contains the JSON type of the data
		"type"?: string

		// Value is the allowed string values for this key
		// Booleans are passed using strconv.ParseBool()
		// Numbers are parsed using as float64 using strconv.ParseFloat()
		// Strings are taken as is
		// Nils this value is ignored
		"value"?: [...string]
	}

	// EmailTrigger refers to the specification of the email
	// notification trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EmailTrigger": {
		// Body refers to the body/content of the email send.
		// +optional
		"body"?: string

		// From refers to the address from which the email is send from.
		// +optional
		"from"?: string

		// Host refers to the smtp host url to which email is send.
		"host"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Port refers to the smtp server port to which email is send.
		// Defaults to 0.
		// +optional
		"port"?: int

		// SMTPPassword refers to the Kubernetes secret that holds the
		// smtp password used to connect to smtp server.
		// +optional
		"smtpPassword"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Subject refers to the subject line for the email send.
		// +optional
		"subject"?: string

		// To refers to the email addresses to which the emails are send.
		// +optional
		"to"?: [...string]

		// Username refers to the username used to connect to the smtp
		// server.
		// +optional
		"username"?: string
	}

	// EmitterEventSource describes the event source for emitter
	// More info at https://emitter.io/develop/getting-started/
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EmitterEventSource": {
		// Broker URI to connect to.
		"broker"?: string

		// ChannelKey refers to the channel key
		"channelKey"?: string

		// ChannelName refers to the channel name
		"channelName"?: string

		// Backoff holds parameters applied to connection.
		// +optional
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Password to use to connect to broker
		// +optional
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// TLS configuration for the emitter client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Username to use to connect to broker
		// +optional
		"username"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// EventContext holds the context of the cloudevent received from
	// an event source.
	// +protobuf.options.(gogoproto.goproto_stringer)=false
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventContext": {
		// DataContentType - A MIME (RFC2046) string describing the media
		// type of `data`.
		"datacontenttype"?: string

		// ID of the event; must be non-empty and unique within the scope
		// of the producer.
		"id"?: string

		// Source - A URI describing the event producer.
		"source"?: string

		// SpecVersion - The version of the CloudEvents specification used
		// by the io.argoproj.workflow.v1alpha1.
		"specversion"?: string

		// Subject - The subject of the event in the context of the event
		// producer
		"subject"?: string

		// Time - A Timestamp when the event happened.
		"time"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// Type - The type of the occurrence which has happened.
		"type"?: string
	}

	// EventDependency describes a dependency
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependency": {
		// EventName is the name of the event
		"eventName"?: string

		// EventSourceName is the name of EventSource that Sensor depends
		// on
		"eventSourceName"?: string

		// Filters and rules governing toleration of success and
		// constraints on the context and data of an event
		"filters"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependencyFilter"

		// FiltersLogicalOperator defines how different filters are
		// evaluated together.
		// Available values: and (&&), or (||)
		// Is optional and if left blank treated as and (&&).
		"filtersLogicalOperator"?: string

		// Name is a unique name of this dependency
		"name"?: string

		// Transform transforms the event data
		"transform"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependencyTransformer"
	}

	// EventDependencyFilter defines filters and constraints for a
	// io.argoproj.workflow.v1alpha1.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependencyFilter": {
		// Context filter constraints
		"context"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventContext"

		// Data filter constraints with escalation
		"data"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.DataFilter"]

		// DataLogicalOperator defines how multiple Data filters (if
		// defined) are evaluated together.
		// Available values: and (&&), or (||)
		// Is optional and if left blank treated as and (&&).
		"dataLogicalOperator"?: string

		// ExprLogicalOperator defines how multiple Exprs filters (if
		// defined) are evaluated together.
		// Available values: and (&&), or (||)
		// Is optional and if left blank treated as and (&&).
		"exprLogicalOperator"?: string

		// Exprs contains the list of expressions evaluated against the
		// event payload.
		"exprs"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ExprFilter"]

		// Script refers to a Lua script evaluated to determine the
		// validity of an io.argoproj.workflow.v1alpha1.
		"script"?: string

		// Time filter on the event with escalation
		"time"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TimeFilter"
	}

	// EventDependencyTransformer transforms the event
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependencyTransformer": {
		// JQ holds the jq command applied for transformation
		// +optional
		"jq"?: string

		// Script refers to a Lua script used to transform the event
		// +optional
		"script"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventPersistence": {
		// Catchup enables to triggered the missed schedule when
		// eventsource restarts
		"catchup"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CatchupConfiguration"

		// ConfigMap holds configmap details for persistence
		"configMap"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConfigMapPersistence"
	}

	// EventSource is the definition of a eventsource resource
	// +genclient
	// +kubebuilder:resource:shortName=es
	// +kubebuilder:subresource:status
	// +k8s:deepcopy-gen:interfaces=io.k8s.apimachinery/pkg/runtime.Object
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSource": {
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"?:     #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceSpec"

		// +optional
		"status"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceStatus"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter": "expression"?: string

	// EventSourceList is the list of eventsource resources
	// +k8s:deepcopy-gen:interfaces=io.k8s.apimachinery/pkg/runtime.Object
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceList": {
		"items"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSource"]
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	// EventSourceSpec refers to specification of event-source
	// resource
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceSpec": {
		// AMQP event sources
		"amqp"?: [string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AMQPEventSource"

		// AzureEventsHub event sources
		"azureEventsHub"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureEventsHubEventSource"
		}

		// AzureQueueStorage event source
		"azureQueueStorage"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureQueueStorageEventSource"
		}

		// Azure Service Bus event source
		"azureServiceBus"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureServiceBusEventSource"
		}

		// Bitbucket event sources
		"bitbucket"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketEventSource"
		}

		// Bitbucket Server event sources
		"bitbucketserver"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BitbucketServerEventSource"
		}

		// Calendar event sources
		"calendar"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CalendarEventSource"
		}

		// Emitter event source
		"emitter"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EmitterEventSource"
		}

		// EventBusName references to a EventBus name. By default the
		// value is "default"
		"eventBusName"?: string

		// File event sources
		"file"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.FileEventSource"
		}

		// Generic event source
		"generic"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GenericEventSource"
		}

		// Gerrit event source
		"gerrit"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GerritEventSource"
		}

		// Github event sources
		"github"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GithubEventSource"
		}

		// Gitlab event sources
		"gitlab"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitlabEventSource"
		}

		// HDFS event sources
		"hdfs"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.HDFSEventSource"
		}

		// Kafka event sources
		"kafka"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaEventSource"
		}

		// Minio event sources
		"minio"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Artifact"
		}

		// MQTT event sources
		"mqtt"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.MQTTEventSource"
		}

		// NATS event sources
		"nats"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSEventsSource"
		}

		// NSQ event source
		"nsq"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NSQEventSource"
		}

		// PubSub event sources
		"pubSub"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PubSubEventSource"
		}

		// Pulsar event source
		"pulsar"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PulsarEventSource"
		}

		// Redis event source
		"redis"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RedisEventSource"
		}

		// Redis stream source
		"redisStream"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RedisStreamEventSource"
		}

		// Replicas is the event source deployment replicas
		"replicas"?: int

		// Resource event sources
		"resource"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ResourceEventSource"
		}

		// Service is the specifications of the service to expose the
		// event source
		// +optional
		"service"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Service"

		// SFTP event sources
		"sftp"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SFTPEventSource"
		}

		// Slack event sources
		"slack"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackEventSource"
		}

		// SNS event sources
		"sns"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SNSEventSource"
		}

		// SQS event sources
		"sqs"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SQSEventSource"
		}

		// StorageGrid event sources
		"storageGrid"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StorageGridEventSource"
		}

		// Stripe event sources
		"stripe"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StripeEventSource"
		}

		// Template is the pod specification for the event source
		// +optional
		"template"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Template"

		// Webhook event sources
		"webhook"?: {
			[string]: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookEventSource"
		}
	}

	// EventSourceStatus holds the status of the event-source resource
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceStatus": "status"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Status"

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ExprFilter": {
		// Expr refers to the expression that determines the outcome of
		// the filter.
		"expr"?: string

		// Fields refers to set of keys that refer to the paths within
		// event payload.
		"fields"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PayloadField"]
	}

	// FileArtifact contains information about an artifact in a
	// filesystem
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.FileArtifact": "path"?: string

	// FileEventSource describes an event-source for file related
	// events.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.FileEventSource": {
		// Type of file operations to watch
		// Refer
		// https://github.com/fsnotify/fsnotify/blob/master/fsnotify.go
		// for more information
		"eventType"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Use polling instead of inotify
		"polling"?: bool

		// WatchPathConfig contains configuration about the file path to
		// watch
		"watchPathConfig"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WatchPathConfig"
	}

	// GenericEventSource refers to a generic event source. It can be
	// used to implement a custom event source.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GenericEventSource": {
		// AuthSecret holds a secret selector that contains a bearer token
		// for authentication
		// +optional
		"authSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Config is the event source configuration
		"config"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Insecure determines the type of connection.
		"insecure"?: bool

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// URL of the gRPC server that implements the event source.
		"url"?: string
	}

	// GerritEventSource refers to event-source related to gerrit
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GerritEventSource": {
		// Auth hosts secret selectors for username and password
		// +optional
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// DeleteHookOnFinish determines whether to delete the Gerrit hook
		// for the project once the event source is stopped.
		// +optional
		"deleteHookOnFinish"?: bool

		// Events are gerrit event to listen to.
		// Refer
		// https://gerrit-review.googlesource.com/Documentation/cmd-stream-events.html#events
		"events"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// GerritBaseURL is the base URL for API requests to a custom
		// endpoint
		"gerritBaseURL"?: string

		// HookName is the name of the webhook
		"hookName"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// List of project namespace paths like "whynowy/test".
		"projects"?: [...string]

		// SslVerify to enable ssl verification
		// +optional
		"sslVerify"?: bool

		// Webhook holds configuration to run a http server
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	// GitArtifact contains information about an artifact stored in
	// git
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitArtifact": {
		// Branch to use to pull trigger resource
		// +optional
		"branch"?: string

		// Directory to clone the repository. We clone complete directory
		// because GitArtifact is not limited to any specific Git service
		// providers.
		// Hence we don't use any specific git provider client.
		"cloneDirectory"?: string

		// Creds contain reference to git username and password
		// +optional
		"creds"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitCreds"

		// Path to file that contains trigger resource definition
		"filePath"?: string

		// Whether to ignore host key
		// +optional
		"insecureIgnoreHostKey"?: bool

		// Ref to use to pull trigger resource. Will result in a shallow
		// clone and
		// fetch.
		// +optional
		"ref"?: string

		// Remote to manage set of tracked repositories. Defaults to
		// "origin".
		// Refer https://git-scm.com/docs/git-remote
		// +optional
		"remote"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitRemoteConfig"

		// SSHKeySecret refers to the secret that contains SSH key
		"sshKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Tag to use to pull trigger resource
		// +optional
		"tag"?: string

		// Git URL
		"url"?: string
	}

	// GitCreds contain reference to git username and password
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitCreds": {
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"
		"username"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// GitRemoteConfig contains the configuration of a Git remote
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitRemoteConfig": {
		// Name of the remote to fetch from.
		"name"?: string

		// URLs the URLs of a remote repository. It must be non-empty.
		// Fetch will
		// always use the first URL, while push will use all of them.
		"urls"?: [...string]
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GithubAppCreds": {
		// AppID refers to the GitHub App ID for the application you
		// created
		"appID"?: string

		// InstallationID refers to the Installation ID of the GitHub app
		// you created and installed
		"installationID"?: string

		// PrivateKey refers to a K8s secret containing the GitHub app
		// private key
		"privateKey"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// GithubEventSource refers to event-source for github related
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GithubEventSource": {
		// Active refers to status of the webhook for event deliveries.
		// https://developer.github.com/webhooks/creating/#active
		// +optional
		"active"?: bool

		// APIToken refers to a K8s secret containing github api token
		// +optional
		"apiToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// ContentType of the event delivery
		"contentType"?: string

		// DeleteHookOnFinish determines whether to delete the GitHub hook
		// for the repository once the event source is stopped.
		// +optional
		"deleteHookOnFinish"?: bool

		// Events refer to Github events to which the event source will
		// subscribe
		"events"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// GitHubApp holds the GitHub app credentials
		// +optional
		"githubApp"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GithubAppCreds"

		// GitHub base URL (for GitHub Enterprise)
		// +optional
		"githubBaseURL"?: string

		// GitHub upload URL (for GitHub Enterprise)
		// +optional
		"githubUploadURL"?: string

		// Id is the webhook's id
		// Deprecated: This is not used at all, will be removed in v1.6
		// +optional
		"id"?: string

		// Insecure tls verification
		"insecure"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Organizations holds the names of organizations (used for
		// organization level webhooks). Not required if Repositories is
		// set.
		"organizations"?: [...string]

		// DeprecatedOwner refers to GitHub owner name i.e. argoproj
		// Deprecated: use Repositories instead. Will be unsupported in v
		// 1.6
		// +optional
		"owner"?: string

		// Repositories holds the information of repositories, which uses
		// repo owner as the key,
		// and list of repo names as the value. Not required if
		// Organizations is set.
		"repositories"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.OwnedRepositories"]

		// DeprecatedRepository refers to GitHub repo name i.e.
		// argo-events
		// Deprecated: use Repositories instead. Will be unsupported in v
		// 1.6
		// +optional
		"repository"?: string

		// Webhook refers to the configuration required to run a http
		// server
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"

		// WebhookSecret refers to K8s secret containing GitHub webhook
		// secret
		// https://developer.github.com/webhooks/securing/
		// +optional
		"webhookSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// GitlabEventSource refers to event-source related to Gitlab
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.GitlabEventSource": {
		// AccessToken references to k8 secret which holds the gitlab api
		// access information
		"accessToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// DeleteHookOnFinish determines whether to delete the GitLab hook
		// for the project once the event source is stopped.
		// +optional
		"deleteHookOnFinish"?: bool

		// EnableSSLVerification to enable ssl verification
		// +optional
		"enableSSLVerification"?: bool

		// Events are gitlab event to listen to.
		// Refer
		// https://github.com/xanzy/go-gitlab/blob/bf34eca5d13a9f4c3f501d8a97b8ac226d55e4d9/projects.go#L794.
		"events"?: [...string]

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// GitlabBaseURL is the base URL for API requests to a custom
		// endpoint
		"gitlabBaseURL"?: string

		// List of group IDs or group name like "test".
		// Group level hook available in Premium and Ultimate Gitlab.
		// +optional
		"groups"?: [...string]

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// DeprecatedProjectID is the id of project for which integration
		// needs to setup
		// Deprecated: use Projects instead. Will be unsupported in v 1.7
		// +optional
		"projectID"?: string

		// List of project IDs or project namespace paths like
		// "whynowy/test".
		// If neither a project nor a group is defined, the EventSource
		// will not manage webhooks.
		// +optional
		"projects"?: [...string]

		// SecretToken references to k8 secret which holds the Secret
		// Token used by webhook config
		"secretToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Webhook holds configuration to run a http server
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	// HDFSEventSource refers to event-source for HDFS related events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.HDFSEventSource": {
		"addresses"?: [...string]

		// CheckInterval is a string that describes an interval duration
		// to check the directory state, e.g. 1s, 30m, 2h... (defaults to
		// 1m)
		"checkInterval"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// HDFSUser is the user to access HDFS file system.
		// It is ignored if either ccache or keytab is used.
		"hdfsUser"?: string

		// KrbCCacheSecret is the secret selector for Kerberos ccache
		// Either ccache or keytab can be set to use Kerberos.
		"krbCCacheSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbConfig is the configmap selector for Kerberos config as
		// string
		// It must be set if either ccache or keytab is used.
		"krbConfigConfigMap"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// KrbKeytabSecret is the secret selector for Kerberos keytab
		// Either ccache or keytab can be set to use Kerberos.
		"krbKeytabSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbRealm is the Kerberos realm used with Kerberos keytab
		// It must be set if keytab is used.
		"krbRealm"?: string

		// KrbServicePrincipalName is the principal name of Kerberos
		// service
		// It must be set if either ccache or keytab is used.
		"krbServicePrincipalName"?: string

		// KrbUsername is the Kerberos username used with Kerberos keytab
		// It must be set if keytab is used.
		"krbUsername"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Type of file operations to watch
		"type"?:            string
		"watchPathConfig"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WatchPathConfig"
	}

	// HTTPTrigger is the trigger for the HTTP request
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.HTTPTrigger": {
		// BasicAuth configuration for the http request.
		// +optional
		"basicAuth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// Headers for the HTTP request.
		// +optional
		"headers"?: {
			[string]: string
		}

		// Method refers to the type of the HTTP request.
		// Refer https://golang.org/src/net/http/method.go for more
		// io.argoproj.workflow.v1alpha1.
		// Default value is POST.
		// +optional
		"method"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the HTTP trigger resource.
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Secure Headers stored in Kubernetes Secrets for the HTTP
		// requests.
		// +optional
		"secureHeaders"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SecureHeader"]

		// Timeout refers to the HTTP request timeout in seconds.
		// Default value is 60 seconds.
		// +optional
		"timeout"?: string

		// TLS configuration for the HTTP client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// URL refers to the URL to send HTTP request to.
		"url"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Int64OrString": {
		"int64Val"?: string
		"strVal"?:   string
		"type"?:     string
	}

	// K8SResource represent arbitrary structured data.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.K8SResource": "value"?: string

	// K8SResourcePolicy refers to the policy used to check the state
	// of K8s based triggers using labels
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.K8SResourcePolicy": {
		// Backoff before checking resource state
		"backoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// ErrorOnBackoffTimeout determines whether sensor should
		// transition to error state if the trigger policy is unable to
		// determine
		// the state of the resource
		"errorOnBackoffTimeout"?: bool

		// Labels required to identify whether a resource is in success
		// state
		"labels"?: {
			[string]: string
		}
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaConsumerGroup": {
		// The name for the consumer group to use
		"groupName"?: string

		// When starting up a new group do we want to start from the
		// oldest event (true) or the newest event (false), defaults to
		// false
		// +optional
		"oldest"?: bool

		// Rebalance strategy can be one of: sticky, roundrobin, range.
		// Range is the default.
		// +optional
		"rebalanceStrategy"?: string
	}

	// KafkaEventSource refers to event-source for Kafka related
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaEventSource": {
		// Yaml format Sarama config for Kafka connection.
		// It follows the struct of sarama.Config. See
		// https://github.com/IBM/sarama/blob/main/config.go
		// e.g.
		//
		// consumer:
		// fetch:
		// min: 1
		// net:
		// MaxOpenRequests: 5
		//
		// +optional
		"config"?: string

		// Backoff holds parameters applied to connection.
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Consumer group for kafka client
		// +optional
		"consumerGroup"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaConsumerGroup"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Sets a limit on how many events get read from kafka per second.
		// +optional
		"limitEventsPerSecond"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Partition name
		// +optional
		"partition"?: string

		// SASL configuration for the kafka client
		// +optional
		"sasl"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SASLConfig"

		// TLS configuration for the kafka client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Topic name
		"topic"?: string

		// URL to kafka cluster, multiple URLs separated by comma
		"url"?: string

		// Specify what kafka version is being connected to enables
		// certain features in sarama, defaults to 1.0.0
		// +optional
		"version"?: string
	}

	// KafkaTrigger refers to the specification of the Kafka trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaTrigger": {
		// Compress determines whether to compress message or not.
		// Defaults to false.
		// If set to true, compresses message using snappy compression.
		// +optional
		"compress"?: bool

		// FlushFrequency refers to the frequency in milliseconds to flush
		// batches.
		// Defaults to 500 milliseconds.
		// +optional
		"flushFrequency"?: int

		// Headers for the Kafka Messages.
		// +optional
		"headers"?: {
			[string]: string
		}

		// Parameters is the list of parameters that is applied to
		// resolved Kafka trigger object.
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// +optional
		// DEPRECATED
		"partition"?: int

		// The partitioning key for the messages put on the Kafka topic.
		// +optional.
		"partitioningKey"?: string

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// RequiredAcks used in producer to tell the broker how many
		// replica acknowledgements
		// Defaults to 1 (Only wait for the leader to ack).
		// +optional.
		"requiredAcks"?: int

		// SASL configuration for the kafka client
		// +optional
		"sasl"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SASLConfig"

		// Schema Registry configuration to producer message with avro
		// format
		// +optional
		"schemaRegistry"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SchemaRegistryConfig"

		// Secure Headers stored in Kubernetes Secrets for the Kafka
		// messages.
		// +optional
		"secureHeaders"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SecureHeader"]

		// TLS configuration for the Kafka producer.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Name of the topic.
		// More info at
		// https://kafka.apache.org/documentation/#intro_topics
		"topic"?: string

		// URL of the Kafka broker, multiple URLs separated by comma.
		"url"?: string

		// Specify what kafka version is being connected to enables
		// certain features in sarama, defaults to 1.0.0
		// +optional
		"version"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.LogTrigger": {
		// Only print messages every interval. Useful to prevent logging
		// too much data for busy events.
		// +optional
		"intervalSeconds"?: string
	}

	// MQTTEventSource refers to event-source for MQTT related events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.MQTTEventSource": {
		// Auth hosts secret selectors for username and password
		// +optional
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// ClientID is the id of the client
		"clientId"?: string

		// ConnectionBackoff holds backoff applied to connection.
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// TLS configuration for the mqtt client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Topic name
		"topic"?: string

		// URL to connect to broker
		"url"?: string
	}

	// Metadata holds the annotations and labels of an event source
	// pod
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Metadata": {
		"annotations"?: [string]: string
		"labels"?: {
			[string]: string
		}
	}

	// NATSAuth refers to the auth info for NATS EventSource
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSAuth": {
		// Baisc auth with username and password
		// +optional
		"basic"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// credential used to connect
		// +optional
		"credential"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// NKey used to connect
		// +optional
		"nkey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Token used to connect
		// +optional
		"token"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// NATSEventsSource refers to event-source for NATS related events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSEventsSource": {
		// Auth information
		// +optional
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSAuth"

		// ConnectionBackoff holds backoff applied to connection.
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Queue is the name of the queue group to subscribe as if
		// specified. Uses QueueSubscribe
		// logic to subscribe as queue group. If the queue is empty, uses
		// default Subscribe logic.
		// +optional
		"queue"?: string

		// Subject holds the name of the subject onto which messages are
		// published
		"subject"?: string

		// TLS configuration for the nats client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// URL to connect to NATS cluster
		"url"?: string
	}

	// NATSTrigger refers to the specification of the NATS trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSTrigger": {
		// AuthInformation
		// +optional
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSAuth"
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Name of the subject to put message on.
		"subject"?: string

		// TLS configuration for the NATS producer.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// URL of the NATS cluster.
		"url"?: string
	}

	// NSQEventSource describes the event source for NSQ PubSub
	// More info at https://godoc.org/github.com/nsqio/go-nsq
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NSQEventSource": {
		// Channel used for subscription
		"channel"?: string

		// Backoff holds parameters applied to connection.
		// +optional
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// HostAddress is the address of the host for NSQ lookup
		"hostAddress"?: string

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// TLS configuration for the nsq client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Topic to subscribe to.
		"topic"?: string
	}

	// OpenWhiskTrigger refers to the specification of the OpenWhisk
	// trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.OpenWhiskTrigger": {
		// Name of the action/function.
		"actionName"?: string

		// AuthToken for authentication.
		// +optional
		"authToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Host URL of the OpenWhisk.
		"host"?: string

		// Namespace for the action.
		// Defaults to "_".
		// +optional.
		"namespace"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Version for the API.
		// Defaults to v1.
		// +optional
		"version"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.OwnedRepositories": {
		// Repository names
		"names"?: [...string]

		// Organization or user name
		"owner"?: string
	}

	// PayloadField binds a value at path within the event payload
	// against a name.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PayloadField": {
		// Name acts as key that holds the value at the path.
		"name"?: string

		// Path is the JSONPath of the event's (JSON decoded) data key
		// Path is a series of keys separated by a dot. A key may contain
		// wildcard characters '*' and '?'.
		// To access an array value use the index as the key. The dot and
		// wildcard characters can be escaped with '\\'.
		// See https://github.com/tidwall/gjson#path-syntax for more
		// information on how to use this.
		"path"?: string
	}

	// PubSubEventSource refers to event-source for GCP PubSub related
	// events.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PubSubEventSource": {
		// CredentialSecret references to the secret that contains JSON
		// credentials to access GCP.
		// If it is missing, it implicitly uses Workload Identity to
		// access.
		// https://cloud.google.com/kubernetes-engine/docs/how-to/workload-identity
		// +optional
		"credentialSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// DeleteSubscriptionOnFinish determines whether to delete the GCP
		// PubSub subscription once the event source is stopped.
		// +optional
		"deleteSubscriptionOnFinish"?: bool

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// ProjectID is GCP project ID for the subscription.
		// Required if you run Argo Events outside of GKE/GCE.
		// (otherwise, the default value is its project)
		// +optional
		"projectID"?: string

		// SubscriptionID is ID of subscription.
		// Required if you use existing subscription.
		// The default value will be auto generated hash based on this
		// eventsource setting, so the subscription
		// might be recreated every time you update the setting, which has
		// a possibility of event loss.
		// +optional
		"subscriptionID"?: string

		// Topic to which the subscription should belongs.
		// Required if you want the eventsource to create a new
		// subscription.
		// If you specify this field along with an existing subscription,
		// it will be verified whether it actually belongs to the
		// specified topic.
		// +optional
		"topic"?: string

		// TopicProjectID is GCP project ID for the topic.
		// By default, it is same as ProjectID.
		// +optional
		"topicProjectID"?: string
	}

	// PulsarEventSource describes the event source for Apache Pulsar
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PulsarEventSource": {
		// Authentication athenz parameters for the pulsar client.
		// Refer
		// https://github.com/apache/pulsar-client-go/blob/master/pulsar/auth/athenz.go
		// Either token or athenz can be set to use auth.
		// +optional
		"authAthenzParams"?: [string]: string

		// Authentication athenz privateKey secret for the pulsar client.
		// AuthAthenzSecret must be set if AuthAthenzParams is used.
		// +optional
		"authAthenzSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Authentication token for the pulsar client.
		// Either token or athenz can be set to use auth.
		// +optional
		"authTokenSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Backoff holds parameters applied to connection.
		// +optional
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// TLS configuration for the pulsar client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Whether the Pulsar client accept untrusted TLS certificate from
		// broker.
		// +optional
		"tlsAllowInsecureConnection"?: bool

		// Trusted TLS certificate secret.
		// +optional
		"tlsTrustCertsSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Whether the Pulsar client verify the validity of the host name
		// from broker.
		// +optional
		"tlsValidateHostname"?: bool

		// Name of the topics to subscribe to.
		// +required
		"topics"?: [...string]

		// Type of the subscription.
		// Only "exclusive" and "shared" is supported.
		// Defaults to exclusive.
		// +optional
		"type"?: string

		// Configure the service URL for the Pulsar service.
		// +required
		"url"?: string
	}

	// PulsarTrigger refers to the specification of the Pulsar
	// trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PulsarTrigger": {
		// Authentication athenz parameters for the pulsar client.
		// Refer
		// https://github.com/apache/pulsar-client-go/blob/master/pulsar/auth/athenz.go
		// Either token or athenz can be set to use auth.
		// +optional
		"authAthenzParams"?: [string]: string

		// Authentication athenz privateKey secret for the pulsar client.
		// AuthAthenzSecret must be set if AuthAthenzParams is used.
		// +optional
		"authAthenzSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Authentication token for the pulsar client.
		// Either token or athenz can be set to use auth.
		// +optional
		"authTokenSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Backoff holds parameters applied to connection.
		// +optional
		"connectionBackoff"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Parameters is the list of parameters that is applied to
		// resolved Kafka trigger object.
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Payload is the list of key-value extracted from an event
		// payload to construct the request payload.
		"payload"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// TLS configuration for the pulsar client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Whether the Pulsar client accept untrusted TLS certificate from
		// broker.
		// +optional
		"tlsAllowInsecureConnection"?: bool

		// Trusted TLS certificate secret.
		// +optional
		"tlsTrustCertsSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Whether the Pulsar client verify the validity of the host name
		// from broker.
		// +optional
		"tlsValidateHostname"?: bool

		// Name of the topic.
		// See https://pulsar.apache.org/docs/en/concepts-messaging/
		"topic"?: string

		// Configure the service URL for the Pulsar service.
		// +required
		"url"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RateLimit": {
		"requestsPerUnit"?: int

		// Defaults to Second
		"unit"?: string
	}

	// RedisEventSource describes an event source for the Redis
	// PubSub.
	// More info at
	// https://godoc.org/github.com/go-redis/redis#example-PubSub
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RedisEventSource": {
		"channels"?: [...string]

		// DB to use. If not specified, default DB 0 will be used.
		// +optional
		"db"?: int

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// HostAddress refers to the address of the Redis host/server
		"hostAddress"?: string

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Namespace to use to retrieve the password from. It should only
		// be specified if password is declared
		// +optional
		"namespace"?: string

		// Password required for authentication if any.
		// +optional
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// TLS configuration for the redis client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Username required for ACL style authentication if any.
		// +optional
		"username"?: string
	}

	// RedisStreamEventSource describes an event source for
	// Redis streams (https://redis.io/topics/streams-intro)
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RedisStreamEventSource": {
		// ConsumerGroup refers to the Redis stream consumer group that
		// will be
		// created on all redis streams. Messages are read through this
		// group. Defaults to 'argo-events-cg'
		// +optional
		"consumerGroup"?: string

		// DB to use. If not specified, default DB 0 will be used.
		// +optional
		"db"?: int

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// HostAddress refers to the address of the Redis host/server
		// (master instance)
		"hostAddress"?: string

		// MaxMsgCountPerRead holds the maximum number of messages per
		// stream that will be read in each XREADGROUP of all streams
		// Example: if there are 2 streams and MaxMsgCountPerRead=10, then
		// each XREADGROUP may read upto a total of 20 messages.
		// Same as COUNT option in
		// XREADGROUP(https://redis.io/topics/streams-intro). Defaults to
		// 10
		// +optional
		"maxMsgCountPerRead"?: int

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Password required for authentication if any.
		// +optional
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Streams to look for entries. XREADGROUP is used on all streams
		// using a single consumer group.
		"streams"?: [...string]

		// TLS configuration for the redis client.
		// +optional
		"tls"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig"

		// Username required for ACL style authentication if any.
		// +optional
		"username"?: string
	}

	// ResourceEventSource refers to a event-source for K8s resource
	// related events.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ResourceEventSource": {
		// EventTypes is the list of event type to watch.
		// Possible values are - ADD, UPDATE and DELETE.
		"eventTypes"?: [...string]

		// Filter is applied on the metadata of the resource
		// If you apply filter, then the internal event informer will only
		// monitor objects that pass the filter.
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ResourceFilter"

		// Group of the resource
		"groupVersionResource"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionResource"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Namespace where resource is deployed
		"namespace"?: string
	}

	// ResourceFilter contains K8s ObjectMeta information to further
	// filter resource event objects
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ResourceFilter": {
		// If the resource is created after the start time then the event
		// is treated as valid.
		// +optional
		"afterStart"?: bool

		// If resource is created before the specified time then the event
		// is treated as valid.
		// +optional
		"createdBy"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// Fields provide field filters similar to K8s field selector
		// (see
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/field-selectors/).
		// Unlike K8s field selector, it supports arbitrary fileds like
		// "spec.serviceAccountName",
		// and the value could be a string or a regex.
		// Same as K8s field selector, operator "=", "==" and "!=" are
		// supported.
		// +optional
		"fields"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Selector"]

		// Labels provide listing options to K8s API to watch resource/s.
		// Refer
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/label-selectors/
		// for more io.argoproj.workflow.v1alpha1.
		// Unlike K8s field selector, multiple values are passed as comma
		// separated values instead of list of values.
		// Eg: value: value1,value2.
		// Same as K8s label selector, operator "=", "==", "!=", "exists",
		// "!", "notin", "in", "gt" and "lt"
		// are supported
		// +optional
		"labels"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Selector"]

		// Prefix filter is applied on the resource name.
		// +optional
		"prefix"?: string
	}

	// S3Artifact contains information about an S3 connection and
	// bucket
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Artifact": {
		"accessKey"?:     #."io.k8s.api.core.v1.SecretKeySelector"
		"bucket"?:        #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Bucket"
		"caCertificate"?: #."io.k8s.api.core.v1.SecretKeySelector"
		"endpoint"?:      string
		"events"?: [...string]
		"filter"?:   #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Filter"
		"insecure"?: bool
		"metadata"?: {
			[string]: string
		}
		"region"?:    string
		"secretKey"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// S3Bucket contains information to describe an S3 Bucket
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Bucket": {
		"key"?:  string
		"name"?: string
	}

	// S3Filter represents filters to apply to bucket notifications
	// for specifying constraints on objects
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.S3Filter": {
		"prefix"?: string
		"suffix"?: string
	}

	// SASLConfig refers to SASL configuration for a client
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SASLConfig": {
		// SASLMechanism is the name of the enabled SASL mechanism.
		// Possible values: OAUTHBEARER, PLAIN (defaults to PLAIN).
		// +optional
		"mechanism"?: string

		// Password for SASL/PLAIN authentication
		"passwordSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// User is the authentication identity (authcid) to present for
		// SASL/PLAIN or SASL/SCRAM authentication
		"userSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// SFTPEventSource describes an event-source for sftp related
	// events.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SFTPEventSource": {
		// Address sftp address.
		"address"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Type of file operations to watch
		// Refer
		// https://github.com/fsnotify/fsnotify/blob/master/fsnotify.go
		// for more information
		"eventType"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Password required for authentication if any.
		"password"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// PollIntervalDuration the interval at which to poll the SFTP
		// server
		// defaults to 10 seconds
		// +optional
		"pollIntervalDuration"?: string

		// SSHKeySecret refers to the secret that contains SSH key. Key
		// needs to contain private key and public key.
		"sshKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Username required for authentication if any.
		"username"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// WatchPathConfig contains configuration about the file path to
		// watch
		"watchPathConfig"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WatchPathConfig"
	}

	// SNSEventSource refers to event-source for AWS SNS related
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SNSEventSource": {
		// AccessKey refers K8s secret containing aws access key
		"accessKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Endpoint configures connection to a specific SNS endpoint
		// instead of Amazons servers
		// +optional
		"endpoint"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Region is AWS region
		"region"?: string

		// RoleARN is the Amazon Resource Name (ARN) of the role to
		// assume.
		// +optional
		"roleARN"?: string

		// SecretKey refers K8s secret containing aws secret key
		"secretKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// TopicArn
		"topicArn"?: string

		// ValidateSignature is boolean that can be set to true for SNS
		// signature verification
		// +optional
		"validateSignature"?: bool

		// Webhook configuration for http server
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	// SQSEventSource refers to event-source for AWS SQS related
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SQSEventSource": {
		// AccessKey refers K8s secret containing aws access key
		"accessKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// DLQ specifies if a dead-letter queue is configured for messages
		// that can't be processed successfully.
		// If set to true, messages with invalid payload won't be
		// acknowledged to allow to forward them farther to the
		// dead-letter queue.
		// The default value is false.
		// +optional
		"dlq"?: bool

		// Endpoint configures connection to a specific SQS endpoint
		// instead of Amazons servers
		// +optional
		"endpoint"?: string

		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// JSONBody specifies that all event body payload coming from this
		// source will be JSON
		// +optional
		"jsonBody"?: bool

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Queue is AWS SQS queue to listen to for messages
		"queue"?: string

		// QueueAccountID is the ID of the account that created the queue
		// to monitor
		// +optional
		"queueAccountId"?: string

		// Region is AWS region
		"region"?: string

		// RoleARN is the Amazon Resource Name (ARN) of the role to
		// assume.
		// +optional
		"roleARN"?: string

		// SecretKey refers K8s secret containing aws secret key
		"secretKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SessionToken refers to K8s secret containing AWS temporary
		// credentials(STS) session token
		// +optional
		"sessionToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// WaitTimeSeconds is The duration (in seconds) for which the call
		// waits for a message to arrive
		// in the queue before returning.
		"waitTimeSeconds"?: string
	}

	// SchemaRegistryConfig refers to configuration for a client
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SchemaRegistryConfig": {
		// +optional
		// SchemaRegistry - basic authentication
		"auth"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.BasicAuth"

		// Schema ID
		"schemaId"?: int

		// Schema Registry URL.
		"url"?: string
	}

	// SecureHeader refers to HTTP Headers with auth tokens as values
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SecureHeader": {
		"name"?: string

		// Values can be read from either secrets or configmaps
		"valueFrom"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ValueFromSource"
	}

	// Selector represents conditional operation to select K8s
	// objects.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Selector": {
		// Key name
		"key"?: string

		// Supported operations like ==, != etc.
		// Defaults to ==.
		// Refer
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors
		// for more io.argoproj.workflow.v1alpha1.
		// +optional
		"operation"?: string

		// Value
		"value"?: string
	}

	// Sensor is the definition of a sensor resource
	// +genclient
	// +genclient:noStatus
	// +kubebuilder:resource:shortName=sn
	// +kubebuilder:subresource:status
	// +k8s:deepcopy-gen:interfaces=io.k8s.apimachinery/pkg/runtime.Object
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Sensor": {
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"?:     #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SensorSpec"

		// +optional
		"status"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SensorStatus"
	}

	// SensorList is the list of Sensor resources
	// +k8s:deepcopy-gen:interfaces=io.k8s.apimachinery/pkg/runtime.Object
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SensorList": {
		"items"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Sensor"]
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	// SensorSpec represents desired sensor state
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SensorSpec": {
		// Dependencies is a list of the events that this sensor is
		// dependent on.
		"dependencies"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventDependency"]

		// ErrorOnFailedRound if set to true, marks sensor state as
		// `error` if the previous trigger round fails.
		// Once sensor state is set to `error`, no further triggers will
		// be processed.
		"errorOnFailedRound"?: bool

		// EventBusName references to a EventBus name. By default the
		// value is "default"
		"eventBusName"?: string

		// LoggingFields add additional key-value pairs when logging
		// happens
		// +optional
		"loggingFields"?: {
			[string]: string
		}

		// Replicas is the sensor deployment replicas
		"replicas"?: int

		// RevisionHistoryLimit specifies how many old deployment
		// revisions to retain
		// +optional
		"revisionHistoryLimit"?: int

		// Template is the pod specification for the sensor
		// +optional
		"template"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Template"

		// Triggers is a list of the things that this sensor evokes. These
		// are the outputs from this sensor.
		"triggers"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Trigger"]
	}

	// SensorStatus contains information about the status of a sensor.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SensorStatus": "status"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Status"

	// Service holds the service information eventsource exposes
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Service": {
		// clusterIP is the IP address of the service and is usually
		// assigned
		// randomly by the master. If an address is specified manually and
		// is not in
		// use by others, it will be allocated to the service; otherwise,
		// creation
		// of the service will fail. This field can not be changed through
		// updates.
		// Valid values are "None", empty string (""), or a valid IP
		// address. "None"
		// can be specified for headless services when proxying is not
		// required.
		// More info:
		// https://kubernetes.io/docs/concepts/services-networking/service/#virtual-ips-and-service-proxies
		// +optional
		"clusterIP"?: string

		// Metadata sets the pods's metadata, i.e. annotations and labels
		// default={annotations: {}, labels: {}}
		"metadata"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Metadata"

		// The list of ports that are exposed by this ClusterIP service.
		// +patchMergeKey=port
		// +patchStrategy=merge
		// +listType=map
		// +listMapKey=port
		// +listMapKey=protocol
		"ports"?: [...#."io.k8s.api.core.v1.ServicePort"]
	}

	// SlackEventSource refers to event-source for Slack related
	// events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackEventSource": {
		// Filter
		// +optional
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Slack App signing secret
		"signingSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Token for URL verification handshake
		"token"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Webhook holds configuration for a REST endpoint
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackSender": {
		// Icon is the Slack application's icon, e.g. :robot_face: or
		// https://example.com/image.png
		// +optional
		"icon"?: string

		// Username is the Slack application's username
		// +optional
		"username"?: string
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackThread": {
		// BroadcastMessageToChannel allows to also broadcast the message
		// from the thread to the channel
		// +optional
		"broadcastMessageToChannel"?: bool

		// MessageAggregationKey allows to aggregate the messages to a
		// thread by some key.
		// +optional
		"messageAggregationKey"?: string
	}

	// SlackTrigger refers to the specification of the slack
	// notification trigger.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackTrigger": {
		// Attachments is a JSON format string that represents an array of
		// Slack attachments according to the attachments API:
		// https://api.slack.com/reference/messaging/attachments .
		// +optional
		"attachments"?: string

		// Blocks is a JSON format string that represents an array of
		// Slack blocks according to the blocks API:
		// https://api.slack.com/reference/block-kit/blocks .
		// +optional
		"blocks"?: string

		// Channel refers to which Slack channel to send Slack message.
		// +optional
		"channel"?: string

		// Message refers to the message to send to the Slack channel.
		// +optional
		"message"?: string

		// Parameters is the list of key-value extracted from event's
		// payload that are applied to
		// the trigger resource.
		// +optional
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Sender refers to additional configuration of the Slack
		// application that sends the message.
		// +optional
		"sender"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackSender"

		// SlackToken refers to the Kubernetes secret that holds the slack
		// token required to send messages.
		"slackToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Thread refers to additional options for sending messages to a
		// Slack thread.
		// +optional
		"thread"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackThread"
	}

	// StandardK8STrigger is the standard Kubernetes resource trigger
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StandardK8STrigger": {
		// LiveObject specifies whether the resource should be directly
		// fetched from K8s instead
		// of being marshaled from the resource artifact. If set to true,
		// the resource artifact
		// must contain the information required to uniquely identify the
		// resource in the cluster,
		// that is, you must specify "apiVersion", "kind" as well as
		// "name" and "namespace" meta
		// data.
		// Only valid for operation type `update`
		// +optional
		"liveObject"?: bool

		// Operation refers to the type of operation performed on the k8s
		// resource.
		// Default value is Create.
		// +optional
		"operation"?: string

		// Parameters is the list of parameters that is applied to
		// resolved K8s trigger object.
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// PatchStrategy controls the K8s object patching strategy when
		// the trigger operation is specified as patch.
		// possible values:
		// "application/json-patch+json"
		// "application/merge-patch+json"
		// "application/strategic-merge-patch+json"
		// "application/apply-patch+yaml".
		// Defaults to "application/merge-patch+json"
		// +optional
		"patchStrategy"?: string

		// Source of the K8s resource file(s)
		"source"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ArtifactLocation"
	}

	// Status is a common structure which can be used for Status
	// field.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Status": {
		// Conditions are the latest available observations of a
		// resource's current state.
		// +optional
		// +patchMergeKey=type
		// +patchStrategy=merge
		"conditions"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Condition"]
	}

	// StatusPolicy refers to the policy used to check the state of
	// the trigger using response status
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StatusPolicy": "allow"?: [...int]

	// StorageGridEventSource refers to event-source for StorageGrid
	// related events
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StorageGridEventSource": {
		// APIURL is the url of the storagegrid api.
		"apiURL"?: string

		// Auth token for storagegrid api
		"authToken"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Name of the bucket to register notifications for.
		"bucket"?: string
		"events"?: [...string]

		// Filter on object key which caused the notification.
		"filter"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StorageGridFilter"

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// S3 region.
		// Defaults to us-east-1
		// +optional
		"region"?: string

		// TopicArn
		"topicArn"?: string

		// Webhook holds configuration for a REST endpoint
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	// StorageGridFilter represents filters to apply to bucket
	// notifications for specifying constraints on objects
	// +k8s:openapi-gen=true
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StorageGridFilter": {
		"prefix"?: string
		"suffix"?: string
	}

	// StripeEventSource describes the event source for stripe webhook
	// notifications
	// More info at https://stripe.com/docs/webhooks
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StripeEventSource": {
		// APIKey refers to K8s secret that holds Stripe API key. Used
		// only if CreateWebhook is enabled.
		// +optional
		"apiKey"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// CreateWebhook if specified creates a new webhook
		// programmatically.
		// +optional
		"createWebhook"?: bool

		// EventFilter describes the type of events to listen to. If not
		// specified, all types of events will be processed.
		// More info at https://stripe.com/docs/api/events/list
		// +optional
		"eventFilter"?: [...string]

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Webhook holds configuration for a REST endpoint
		"webhook"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	// TLSConfig refers to TLS configuration for a client.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TLSConfig": {
		// CACertSecret refers to the secret that contains the CA cert
		"caCertSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// ClientCertSecret refers to the secret that contains the client
		// cert
		"clientCertSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// ClientKeySecret refers to the secret that contains the client
		// key
		"clientKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// If true, skips creation of TLSConfig with certs and creates an
		// empty TLSConfig. (Defaults to false)
		// +optional
		"insecureSkipVerify"?: bool
	}

	// Template holds the information of a deployment template
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Template": {
		// If specified, the pod's scheduling constraints
		// +optional
		"affinity"?: #."io.k8s.api.core.v1.Affinity"

		// Container is the main container image to run in the sensor pod
		// +optional
		"container"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Container"

		// ImagePullSecrets is an optional list of references to secrets
		// in the same namespace to use for pulling any of the images
		// used by this PodSpec.
		// If specified, these secrets will be passed to individual puller
		// implementations for them to use. For example,
		// in the case of docker, only DockerConfig type secrets are
		// honored.
		// More info:
		// https://kubernetes.io/docs/concepts/containers/images#specifying-imagepullsecrets-on-a-pod
		// +optional
		// +patchMergeKey=name
		// +patchStrategy=merge
		"imagePullSecrets"?: [...#."io.k8s.api.core.v1.LocalObjectReference"]

		// Metadata sets the pods's metadata, i.e. annotations and labels
		"metadata"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Metadata"

		// NodeSelector is a selector which must be true for the pod to
		// fit on a node.
		// Selector which must match a node's labels for the pod to be
		// scheduled on that node.
		// More info:
		// https://kubernetes.io/docs/concepts/configuration/assign-pod-node/
		// +optional
		"nodeSelector"?: {
			[string]: string
		}

		// The priority value. Various system components use this field to
		// find the
		// priority of the EventSource pod. When Priority Admission
		// Controller is enabled,
		// it prevents users from setting this field. The admission
		// controller populates
		// this field from PriorityClassName.
		// The higher the value, the higher the priority.
		// More info:
		// https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/
		// +optional
		"priority"?: int

		// If specified, indicates the EventSource pod's priority.
		// "system-node-critical"
		// and "system-cluster-critical" are two special keywords which
		// indicate the
		// highest priorities with the former being the highest priority.
		// Any other
		// name must be defined by creating a PriorityClass object with
		// that name.
		// If not specified, the pod priority will be default or zero if
		// there is no
		// default.
		// More info:
		// https://kubernetes.io/docs/concepts/configuration/pod-priority-preemption/
		// +optional
		"priorityClassName"?: string

		// SecurityContext holds pod-level security attributes and common
		// container settings.
		// Optional: Defaults to empty. See type description for default
		// values of each field.
		// +optional
		"securityContext"?: #."io.k8s.api.core.v1.PodSecurityContext"

		// ServiceAccountName is the name of the ServiceAccount to use to
		// run sensor pod.
		// More info:
		// https://kubernetes.io/docs/tasks/configure-pod-container/configure-service-account/
		// +optional
		"serviceAccountName"?: string

		// If specified, the pod's tolerations.
		// +optional
		"tolerations"?: [...#."io.k8s.api.core.v1.Toleration"]

		// Volumes is a list of volumes that can be mounted by containers
		// in a io.argoproj.workflow.v1alpha1.
		// +patchStrategy=merge
		// +patchMergeKey=name
		// +optional
		"volumes"?: [...#."io.k8s.api.core.v1.Volume"]
	}

	// TimeFilter describes a window in time.
	// It filters out events that occur outside the time limits.
	// In other words, only events that occur after Start and before
	// Stop
	// will pass this filter.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TimeFilter": {
		// Start is the beginning of a time window in UTC.
		// Before this time, events for this dependency are ignored.
		// Format is hh:mm:ss.
		"start"?: string

		// Stop is the end of a time window in UTC.
		// After or equal to this time, events for this dependency are
		// ignored and
		// Format is hh:mm:ss.
		// If it is smaller than Start, it is treated as next day of Start
		// (e.g.: 22:00:00-01:00:00 means 22:00:00-25:00:00).
		"stop"?: string
	}

	// Trigger is an action taken, output produced, an event created,
	// a message sent
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Trigger": {
		// AtLeastOnce determines the trigger execution semantics.
		// Defaults to false. Trigger execution will use at-most-once
		// semantics.
		// If set to true, Trigger execution will switch to at-least-once
		// semantics.
		// +kubebuilder:default=false
		// +optional
		"atLeastOnce"?: bool

		// If the trigger fails, it will retry up to the configured number
		// of
		// retries. If the maximum retries are reached and the trigger is
		// set to
		// execute atLeastOnce, the dead letter queue (DLQ) trigger will
		// be invoked if
		// specified. Invoking the dead letter queue trigger helps prevent
		// data
		// loss.
		// +optional
		"dlqTrigger"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Trigger"

		// Parameters is the list of parameters applied to the trigger
		// template definition
		"parameters"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter"]

		// Policy to configure backoff and execution criteria for the
		// trigger
		// +optional
		"policy"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerPolicy"

		// Rate limit, default unit is Second
		// +optional
		"rateLimit"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.RateLimit"

		// Retry strategy, defaults to no retry
		// +optional
		"retryStrategy"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Backoff"

		// Template describes the trigger specification.
		"template"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerTemplate"
	}

	// TriggerParameter indicates a passed parameter to a service
	// template
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameter": {
		// Dest is the JSONPath of a resource key.
		// A path is a series of keys separated by a dot. The colon
		// character can be escaped with '.'
		// The -1 key can be used to append a value to an existing array.
		// See https://github.com/tidwall/sjson#path-syntax for more
		// information about how this is used.
		"dest"?: string

		// Operation is what to do with the existing value at Dest,
		// whether to
		// 'prepend', 'overwrite', or 'append' it.
		"operation"?: string

		// Src contains a source reference to the value of the parameter
		// from a dependency
		"src"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameterSource"
	}

	// TriggerParameterSource defines the source for a parameter from
	// a event event
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerParameterSource": {
		// ContextKey is the JSONPath of the event's (JSON decoded)
		// context key
		// ContextKey is a series of keys separated by a dot. A key may
		// contain wildcard characters '*' and '?'.
		// To access an array value use the index as the key. The dot and
		// wildcard characters can be escaped with '\\'.
		// See https://github.com/tidwall/gjson#path-syntax for more
		// information on how to use this.
		"contextKey"?: string

		// ContextTemplate is a go-template for extracting a string from
		// the event's context.
		// If a ContextTemplate is provided with a ContextKey, the
		// template will be evaluated first and fallback to the
		// ContextKey.
		// The templating follows the standard go-template syntax as well
		// as sprig's extra functions.
		// See https://pkg.go.dev/text/template and
		// https://masterminds.github.io/sprig/
		"contextTemplate"?: string

		// DataKey is the JSONPath of the event's (JSON decoded) data key
		// DataKey is a series of keys separated by a dot. A key may
		// contain wildcard characters '*' and '?'.
		// To access an array value use the index as the key. The dot and
		// wildcard characters can be escaped with '\\'.
		// See https://github.com/tidwall/gjson#path-syntax for more
		// information on how to use this.
		"dataKey"?: string

		// DataTemplate is a go-template for extracting a string from the
		// event's data.
		// If a DataTemplate is provided with a DataKey, the template will
		// be evaluated first and fallback to the DataKey.
		// The templating follows the standard go-template syntax as well
		// as sprig's extra functions.
		// See https://pkg.go.dev/text/template and
		// https://masterminds.github.io/sprig/
		"dataTemplate"?: string

		// DependencyName refers to the name of the dependency. The event
		// which is stored for this dependency is used as payload
		// for the parameterization. Make sure to refer to one of the
		// dependencies you have defined under Dependencies list.
		"dependencyName"?: string

		// UseRawData indicates if the value in an event at data key
		// should be used without converting to string.
		// When true, a number, boolean, json or string parameter may be
		// extracted. When the field is unspecified, or explicitly
		// false, the behavior is to turn the extracted field into a
		// string. (e.g. when set to true, the parameter
		// 123 will resolve to the numerical type, but when false, or not
		// provided, the string "123" will be resolved)
		// +optional
		"useRawData"?: bool

		// Value is the default literal value to use for this parameter
		// source
		// This is only used if the DataKey is invalid.
		// If the DataKey is invalid and this is not defined, this param
		// source will produce an error.
		"value"?: string
	}

	// TriggerPolicy dictates the policy for the trigger retries
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerPolicy": {
		// K8SResourcePolicy refers to the policy used to check the state
		// of K8s based triggers using using labels
		"k8s"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.K8SResourcePolicy"

		// Status refers to the policy used to check the state of the
		// trigger using response status
		"status"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StatusPolicy"
	}

	// TriggerTemplate is the template that describes trigger
	// specification.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.TriggerTemplate": {
		// ArgoWorkflow refers to the trigger that can perform various
		// operations on an Argo io.argoproj.workflow.v1alpha1.
		// +optional
		"argoWorkflow"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ArgoWorkflowTrigger"

		// AWSLambda refers to the trigger designed to invoke AWS Lambda
		// function with with on-the-fly constructable payload.
		// +optional
		"awsLambda"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AWSLambdaTrigger"

		// AzureEventHubs refers to the trigger send an event to an Azure
		// Event Hub.
		// +optional
		"azureEventHubs"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureEventHubsTrigger"

		// AzureServiceBus refers to the trigger designed to place
		// messages on Azure Service Bus
		// +optional
		"azureServiceBus"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.AzureServiceBusTrigger"

		// Conditions is the conditions to execute the trigger.
		// For example: "(dep01 || dep02) && dep04"
		// +optional
		"conditions"?: string

		// Criteria to reset the conditons
		// +optional
		"conditionsReset"?: [...#."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ConditionsResetCriteria"]

		// CustomTrigger refers to the trigger designed to connect to a
		// gRPC trigger server and execute a custom trigger.
		// +optional
		"custom"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.CustomTrigger"

		// Email refers to the trigger designed to send an email
		// notification
		// +optional
		"email"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EmailTrigger"

		// HTTP refers to the trigger designed to dispatch a HTTP request
		// with on-the-fly constructable payload.
		// +optional
		"http"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.HTTPTrigger"

		// StandardK8STrigger refers to the trigger designed to create or
		// update a generic Kubernetes resource.
		// +optional
		"k8s"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.StandardK8STrigger"

		// Kafka refers to the trigger designed to place messages on Kafka
		// topic.
		// +optional.
		"kafka"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.KafkaTrigger"

		// Log refers to the trigger designed to invoke log the
		// io.argoproj.workflow.v1alpha1.
		// +optional
		"log"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.LogTrigger"

		// Name is a unique name of the action to take.
		"name"?: string

		// NATS refers to the trigger designed to place message on NATS
		// subject.
		// +optional.
		"nats"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.NATSTrigger"

		// OpenWhisk refers to the trigger designed to invoke OpenWhisk
		// action.
		// +optional
		"openWhisk"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.OpenWhiskTrigger"

		// Pulsar refers to the trigger designed to place messages on
		// Pulsar topic.
		// +optional
		"pulsar"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.PulsarTrigger"

		// Slack refers to the trigger designed to send slack notification
		// message.
		// +optional
		"slack"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.SlackTrigger"
	}

	// URLArtifact contains information about an artifact at an http
	// endpoint.
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.URLArtifact": {
		// Path is the complete URL
		"path"?: string

		// VerifyCert decides whether the connection is secure or not
		"verifyCert"?: bool
	}

	// ValueFromSource allows you to reference keys from either a
	// Configmap or Secret
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.ValueFromSource": {
		"configMapKeyRef"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"
		"secretKeyRef"?:    #."io.k8s.api.core.v1.SecretKeySelector"
	}

	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WatchPathConfig": {
		// Directory to watch for events
		"directory"?: string

		// Path is relative path of object to watch with respect to the
		// directory
		"path"?: string

		// PathRegexp is regexp of relative path of object to watch with
		// respect to the directory
		"pathRegexp"?: string
	}

	// WebhookContext holds a general purpose REST API context
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext": {
		// AuthSecret holds a secret selector that contains a bearer token
		// for authentication
		// +optional
		"authSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// REST API endpoint
		"endpoint"?: string

		// MaxPayloadSize is the maximum webhook payload size that the
		// server will accept.
		// Requests exceeding that limit will be rejected with "request
		// too large" response.
		// Default value: 1048576 (1MB).
		// +optional
		"maxPayloadSize"?: string

		// Metadata holds the user defined metadata which will passed
		// along the event payload.
		// +optional
		"metadata"?: {
			[string]: string
		}

		// Method is HTTP request method that indicates the desired action
		// to be performed for a given resource.
		// See RFC7231 Hypertext Transfer Protocol (HTTP/1.1): Semantics
		// and Content
		"method"?: string

		// Port on which HTTP server is listening for incoming events.
		"port"?: string

		// ServerCertPath refers the file that contains the cert.
		"serverCertSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// ServerKeyPath refers the file that contains private key
		"serverKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// URL is the url of the server.
		"url"?: string
	}

	// CalendarEventSource describes an HTTP based EventSource
	#: "github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookEventSource": {
		// Filter
		// +optional
		"filter"?:         #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.EventSourceFilter"
		"webhookContext"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.WebhookContext"
	}

	#: "google.protobuf.Any": {
		"type_url"?: string
		"value"?:    string
	}

	#: "grpc.gateway.runtime.Error": {
		"code"?: int
		"details"?: [...#."google.protobuf.Any"]
		"error"?:   string
		"message"?: string
	}

	#: "grpc.gateway.runtime.StreamError": {
		"details"?: [...#."google.protobuf.Any"]
		"grpc_code"?:   int
		"http_code"?:   int
		"http_status"?: string
		"message"?:     string
	}

	// Amount represent a numeric amount.
	#: "io.argoproj.workflow.v1alpha1.Amount": number

	// ArchiveStrategy describes how to archive files/directory when
	// saving artifacts
	#: "io.argoproj.workflow.v1alpha1.ArchiveStrategy": {
		"none"?: #."io.argoproj.workflow.v1alpha1.NoneStrategy"
		"tar"?:  #."io.argoproj.workflow.v1alpha1.TarStrategy"
		"zip"?:  #."io.argoproj.workflow.v1alpha1.ZipStrategy"
	}

	#: "io.argoproj.workflow.v1alpha1.ArchivedWorkflowDeletedResponse": {}

	// Arguments to a template
	#: "io.argoproj.workflow.v1alpha1.Arguments": {
		// Artifacts is the list of artifacts to pass to the template or
		// workflow
		"artifacts"?: [...#."io.argoproj.workflow.v1alpha1.Artifact"]

		// Parameters is the list of parameters to pass to the template or
		// workflow
		"parameters"?: [...#."io.argoproj.workflow.v1alpha1.Parameter"]
	}

	// ArtGCStatus maintains state related to ArtifactGC
	#: "io.argoproj.workflow.v1alpha1.ArtGCStatus": {
		// if this is true, we already checked to see if we need to do it
		// and we don't
		"notSpecified"?: bool

		// have completed Pods been processed? (mapped by Pod name) used
		// to prevent re-processing the Status of a Pod more than once
		"podsRecouped"?: {
			[string]: bool
		}

		// have Pods been started to perform this strategy? (enables us
		// not to re-process what we've already done)
		"strategiesProcessed"?: {
			[string]: bool
		}
	}

	// Artifact indicates an artifact to place at a specified path
	#: "io.argoproj.workflow.v1alpha1.Artifact": {
		// Archive controls how the artifact will be saved to the artifact
		// repository.
		"archive"?: #."io.argoproj.workflow.v1alpha1.ArchiveStrategy"

		// ArchiveLogs indicates if the container logs should be archived
		"archiveLogs"?: bool

		// ArtifactGC describes the strategy to use when to deleting an
		// artifact from completed or deleted workflows
		"artifactGC"?: #."io.argoproj.workflow.v1alpha1.ArtifactGC"

		// Artifactory contains artifactory artifact location details
		"artifactory"?: #."io.argoproj.workflow.v1alpha1.ArtifactoryArtifact"

		// Azure contains Azure Storage artifact location details
		"azure"?: #."io.argoproj.workflow.v1alpha1.AzureArtifact"

		// Has this been deleted?
		"deleted"?: bool

		// From allows an artifact to reference an artifact from a
		// previous step
		"from"?: string

		// FromExpression, if defined, is evaluated to specify the value
		// for the artifact
		"fromExpression"?: string

		// GCS contains GCS artifact location details
		"gcs"?: #."io.argoproj.workflow.v1alpha1.GCSArtifact"

		// Git contains git artifact location details
		"git"?: #."io.argoproj.workflow.v1alpha1.GitArtifact"

		// GlobalName exports an output artifact to the global scope,
		// making it available as
		// '{{io.argoproj.workflow.v1alpha1.outputs.artifacts.XXXX}} and
		// in workflow.status.outputs.artifacts
		"globalName"?: string

		// HDFS contains HDFS artifact location details
		"hdfs"?: #."io.argoproj.workflow.v1alpha1.HDFSArtifact"

		// HTTP contains HTTP artifact location details
		"http"?: #."io.argoproj.workflow.v1alpha1.HTTPArtifact"

		// mode bits to use on this file, must be a value between 0 and
		// 0777. Set when loading input artifacts. It is recommended to
		// set the mode value to ensure the artifact has the expected
		// permissions in your container.
		"mode"?: int

		// name of the artifact. must be unique within a template's
		// inputs/outputs.
		"name"!: string

		// Make Artifacts optional, if Artifacts doesn't generate or exist
		"optional"?: bool

		// OSS contains OSS artifact location details
		"oss"?: #."io.argoproj.workflow.v1alpha1.OSSArtifact"

		// Path is the container path to the artifact
		"path"?: string

		// Plugin contains plugin artifact location details
		"plugin"?: #."io.argoproj.workflow.v1alpha1.PluginArtifact"

		// Raw contains raw artifact location details
		"raw"?: #."io.argoproj.workflow.v1alpha1.RawArtifact"

		// If mode is set, apply the permission recursively into the
		// artifact if it is a folder
		"recurseMode"?: bool

		// S3 contains S3 artifact location details
		"s3"?: #."io.argoproj.workflow.v1alpha1.S3Artifact"

		// SubPath allows an artifact to be sourced from a subpath within
		// the specified source
		"subPath"?: string
	}

	// ArtifactGC describes how to delete artifacts from completed
	// Workflows - this is embedded into the WorkflowLevelArtifactGC,
	// and also used for individual Artifacts to override that as
	// needed
	#: "io.argoproj.workflow.v1alpha1.ArtifactGC": {
		// PodMetadata is an optional field for specifying the Labels and
		// Annotations that should be assigned to the Pod doing the
		// deletion
		"podMetadata"?: #."io.argoproj.workflow.v1alpha1.Metadata"

		// ServiceAccountName is an optional field for specifying the
		// Service Account that should be assigned to the Pod doing the
		// deletion
		"serviceAccountName"?: string

		// Strategy is the strategy to use.
		"strategy"?: string
	}

	// ArtifactLocation describes a location for a single or multiple
	// artifacts. It is used as single artifact in the context of
	// inputs/outputs (e.g. outputs.artifacts.artname). It is also
	// used to describe the location of multiple artifacts such as
	// the archive location of a single workflow step, which the
	// executor will use as a default location to store its files.
	#: "io.argoproj.workflow.v1alpha1.ArtifactLocation": {
		// ArchiveLogs indicates if the container logs should be archived
		"archiveLogs"?: bool

		// Artifactory contains artifactory artifact location details
		"artifactory"?: #."io.argoproj.workflow.v1alpha1.ArtifactoryArtifact"

		// Azure contains Azure Storage artifact location details
		"azure"?: #."io.argoproj.workflow.v1alpha1.AzureArtifact"

		// GCS contains GCS artifact location details
		"gcs"?: #."io.argoproj.workflow.v1alpha1.GCSArtifact"

		// Git contains git artifact location details
		"git"?: #."io.argoproj.workflow.v1alpha1.GitArtifact"

		// HDFS contains HDFS artifact location details
		"hdfs"?: #."io.argoproj.workflow.v1alpha1.HDFSArtifact"

		// HTTP contains HTTP artifact location details
		"http"?: #."io.argoproj.workflow.v1alpha1.HTTPArtifact"

		// OSS contains OSS artifact location details
		"oss"?: #."io.argoproj.workflow.v1alpha1.OSSArtifact"

		// Plugin contains plugin artifact location details
		"plugin"?: #."io.argoproj.workflow.v1alpha1.PluginArtifact"

		// Raw contains raw artifact location details
		"raw"?: #."io.argoproj.workflow.v1alpha1.RawArtifact"

		// S3 contains S3 artifact location details
		"s3"?: #."io.argoproj.workflow.v1alpha1.S3Artifact"
	}

	// ArtifactPaths expands a step from a collection of artifacts
	#: "io.argoproj.workflow.v1alpha1.ArtifactPaths": {
		// Archive controls how the artifact will be saved to the artifact
		// repository.
		"archive"?: #."io.argoproj.workflow.v1alpha1.ArchiveStrategy"

		// ArchiveLogs indicates if the container logs should be archived
		"archiveLogs"?: bool

		// ArtifactGC describes the strategy to use when to deleting an
		// artifact from completed or deleted workflows
		"artifactGC"?: #."io.argoproj.workflow.v1alpha1.ArtifactGC"

		// Artifactory contains artifactory artifact location details
		"artifactory"?: #."io.argoproj.workflow.v1alpha1.ArtifactoryArtifact"

		// Azure contains Azure Storage artifact location details
		"azure"?: #."io.argoproj.workflow.v1alpha1.AzureArtifact"

		// Has this been deleted?
		"deleted"?: bool

		// From allows an artifact to reference an artifact from a
		// previous step
		"from"?: string

		// FromExpression, if defined, is evaluated to specify the value
		// for the artifact
		"fromExpression"?: string

		// GCS contains GCS artifact location details
		"gcs"?: #."io.argoproj.workflow.v1alpha1.GCSArtifact"

		// Git contains git artifact location details
		"git"?: #."io.argoproj.workflow.v1alpha1.GitArtifact"

		// GlobalName exports an output artifact to the global scope,
		// making it available as
		// '{{io.argoproj.workflow.v1alpha1.outputs.artifacts.XXXX}} and
		// in workflow.status.outputs.artifacts
		"globalName"?: string

		// HDFS contains HDFS artifact location details
		"hdfs"?: #."io.argoproj.workflow.v1alpha1.HDFSArtifact"

		// HTTP contains HTTP artifact location details
		"http"?: #."io.argoproj.workflow.v1alpha1.HTTPArtifact"

		// mode bits to use on this file, must be a value between 0 and
		// 0777. Set when loading input artifacts. It is recommended to
		// set the mode value to ensure the artifact has the expected
		// permissions in your container.
		"mode"?: int

		// name of the artifact. must be unique within a template's
		// inputs/outputs.
		"name"!: string

		// Make Artifacts optional, if Artifacts doesn't generate or exist
		"optional"?: bool

		// OSS contains OSS artifact location details
		"oss"?: #."io.argoproj.workflow.v1alpha1.OSSArtifact"

		// Path is the container path to the artifact
		"path"?: string

		// Plugin contains plugin artifact location details
		"plugin"?: #."io.argoproj.workflow.v1alpha1.PluginArtifact"

		// Raw contains raw artifact location details
		"raw"?: #."io.argoproj.workflow.v1alpha1.RawArtifact"

		// If mode is set, apply the permission recursively into the
		// artifact if it is a folder
		"recurseMode"?: bool

		// S3 contains S3 artifact location details
		"s3"?: #."io.argoproj.workflow.v1alpha1.S3Artifact"

		// SubPath allows an artifact to be sourced from a subpath within
		// the specified source
		"subPath"?: string
	}

	// ArtifactRepository represents an artifact repository in which a
	// controller will store its artifacts
	#: "io.argoproj.workflow.v1alpha1.ArtifactRepository": {
		// ArchiveLogs enables log archiving
		"archiveLogs"?: bool

		// Artifactory stores artifacts to JFrog Artifactory
		"artifactory"?: #."io.argoproj.workflow.v1alpha1.ArtifactoryArtifactRepository"

		// Azure stores artifact in an Azure Storage account
		"azure"?: #."io.argoproj.workflow.v1alpha1.AzureArtifactRepository"

		// GCS stores artifact in a GCS object store
		"gcs"?: #."io.argoproj.workflow.v1alpha1.GCSArtifactRepository"

		// HDFS stores artifacts in HDFS
		"hdfs"?: #."io.argoproj.workflow.v1alpha1.HDFSArtifactRepository"

		// OSS stores artifact in a OSS-compliant object store
		"oss"?: #."io.argoproj.workflow.v1alpha1.OSSArtifactRepository"

		// Plugin stores artifact in a plugin-specific artifact repository
		"plugin"?: #."io.argoproj.workflow.v1alpha1.PluginArtifactRepository"

		// S3 stores artifact in a S3-compliant object store
		"s3"?: #."io.argoproj.workflow.v1alpha1.S3ArtifactRepository"
	}

	#: "io.argoproj.workflow.v1alpha1.ArtifactRepositoryRef": {
		// The name of the config map. Defaults to
		// "artifact-repositories".
		"configMap"?: string

		// The config map key. Defaults to the value of the
		// "workflows.argoproj.io/default-artifact-repository"
		// annotation.
		"key"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.ArtifactRepositoryRefStatus": {
		// The repository the workflow will use. This maybe empty before
		// v3.1.
		"artifactRepository"?: #."io.argoproj.workflow.v1alpha1.ArtifactRepository"

		// The name of the config map. Defaults to
		// "artifact-repositories".
		"configMap"?: string

		// If this ref represents the default artifact repository, rather
		// than a config map.
		"default"?: bool

		// The config map key. Defaults to the value of the
		// "workflows.argoproj.io/default-artifact-repository"
		// annotation.
		"key"?: string

		// The namespace of the config map. Defaults to the workflow's
		// namespace, or the controller's namespace (if found).
		"namespace"?: string
	}

	// ArtifactoryArtifact is the location of an artifactory artifact
	#: "io.argoproj.workflow.v1alpha1.ArtifactoryArtifact": {
		// PasswordSecret is the secret selector to the repository
		// password
		"passwordSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// URL of the artifact
		"url"!: string

		// UsernameSecret is the secret selector to the repository
		// username
		"usernameSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// ArtifactoryArtifactRepository defines the controller
	// configuration for an artifactory artifact repository
	#: "io.argoproj.workflow.v1alpha1.ArtifactoryArtifactRepository": {
		// KeyFormat defines the format of how to store keys and can
		// reference workflow variables.
		"keyFormat"?: string

		// PasswordSecret is the secret selector to the repository
		// password
		"passwordSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// RepoURL is the url for artifactory repo.
		"repoURL"?: string

		// UsernameSecret is the secret selector to the repository
		// username
		"usernameSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// AzureArtifact is the location of an Azure Storage artifact
	#: "io.argoproj.workflow.v1alpha1.AzureArtifact": {
		// AccountKeySecret is the secret selector to the Azure Blob
		// Storage account access key
		"accountKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Blob is the blob name (i.e., path) in the container where the
		// artifact resides
		"blob"!: string

		// Container is the container where resources will be stored
		"container"!: string

		// Endpoint is the service url associated with an account. It is
		// most likely "https://<ACCOUNT_NAME>.blob.core.windows.net"
		"endpoint"!: string

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// AzureArtifactRepository defines the controller configuration
	// for an Azure Blob Storage artifact repository
	#: "io.argoproj.workflow.v1alpha1.AzureArtifactRepository": {
		// AccountKeySecret is the secret selector to the Azure Blob
		// Storage account access key
		"accountKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// BlobNameFormat is defines the format of how to store blob
		// names. Can reference workflow variables
		"blobNameFormat"?: string

		// Container is the container where resources will be stored
		"container"!: string

		// Endpoint is the service url associated with an account. It is
		// most likely "https://<ACCOUNT_NAME>.blob.core.windows.net"
		"endpoint"!: string

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// Backoff is a backoff strategy to use within retryStrategy
	#: "io.argoproj.workflow.v1alpha1.Backoff": {
		// Cap is a limit on revised values of the duration parameter. If
		// a multiplication by the factor parameter would make the
		// duration exceed the cap then the duration is set to the cap
		"cap"?: string

		// Duration is the amount to back off. Default unit is seconds,
		// but could also be a duration (e.g. "2m", "1h")
		"duration"?: string

		// Factor is a factor to multiply the base duration after each
		// failed retry
		"factor"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// MaxDuration is the maximum amount of time allowed for a
		// workflow in the backoff strategy. It is important to note that
		// if the workflow template includes activeDeadlineSeconds, the
		// pod's deadline is initially set with activeDeadlineSeconds.
		// However, when the workflow fails, the pod's deadline is then
		// overridden by maxDuration. This ensures that the workflow does
		// not exceed the specified maximum duration when retries are
		// involved.
		"maxDuration"?: string
	}

	// BasicAuth describes the secret selectors required for basic
	// authentication
	#: "io.argoproj.workflow.v1alpha1.BasicAuth": {
		// PasswordSecret is the secret selector to the repository
		// password
		"passwordSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// UsernameSecret is the secret selector to the repository
		// username
		"usernameSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// Cache is the configuration for the type of cache to be used
	#: "io.argoproj.workflow.v1alpha1.Cache": {
		// ConfigMap sets a ConfigMap-based cache
		"configMap"!: #."io.k8s.api.core.v1.LocalObjectReference"
	}

	// ClientCertAuth holds necessary information for client
	// authentication via certificates
	#: "io.argoproj.workflow.v1alpha1.ClientCertAuth": {
		"clientCertSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
		"clientKeySecret"?:  #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// ClusterWorkflowTemplate is the definition of a workflow
	// template resource in cluster scope
	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: "argoproj.io/v1alpha1"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     "ClusterWorkflowTemplate"
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"!:     #."io.argoproj.workflow.v1alpha1.WorkflowSpec"
	}

	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplateCreateRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"template"?:      #."io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate"
	}

	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplateDeleteResponse": {}

	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplateLintRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"template"?:      #."io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate"
	}

	// ClusterWorkflowTemplateList is list of ClusterWorkflowTemplate
	// resources
	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplateList": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string
		"items"!: [...#."io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate"]

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     string
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	#: "io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplateUpdateRequest": {
		// DEPRECATED: This field is ignored.
		"name"?:     string
		"template"?: #."io.argoproj.workflow.v1alpha1.ClusterWorkflowTemplate"
	}

	#: "io.argoproj.workflow.v1alpha1.CollectEventRequest": "name"?: string

	#: "io.argoproj.workflow.v1alpha1.CollectEventResponse": {}

	// Column is a custom column that will be exposed in the Workflow
	// List View.
	#: "io.argoproj.workflow.v1alpha1.Column": {
		// The key of the label or annotation, e.g.,
		// "workflows.argoproj.io/completed".
		"key"!: string

		// The name of this column, e.g., "Workflow Completed".
		"name"!: string

		// The type of this column, "label" or "annotation".
		"type"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.Condition": {
		// Message is the condition message
		"message"?: string

		// Status is the status of the condition
		"status"?: string

		// Type is the type of condition
		"type"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.ContainerNode": {
		// Arguments to the entrypoint. The container image's CMD is used
		// if this is not provided. Variable references $(VAR_NAME) are
		// expanded using the container's environment. If a variable
		// cannot be resolved, the reference in the input string will be
		// unchanged. Double $$ are reduced to a single $, which allows
		// for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will
		// produce the string literal "$(VAR_NAME)". Escaped references
		// will never be expanded, regardless of whether the variable
		// exists or not. Cannot be updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"args"?: [...string]

		// Entrypoint array. Not executed within a shell. The container
		// image's ENTRYPOINT is used if this is not provided. Variable
		// references $(VAR_NAME) are expanded using the container's
		// environment. If a variable cannot be resolved, the reference
		// in the input string will be unchanged. Double $$ are reduced
		// to a single $, which allows for escaping the $(VAR_NAME)
		// syntax: i.e. "$$(VAR_NAME)" will produce the string literal
		// "$(VAR_NAME)". Escaped references will never be expanded,
		// regardless of whether the variable exists or not. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"command"?: [...string]
		"dependencies"?: [...string]

		// List of environment variables to set in the container. Cannot
		// be updated.
		"env"?: [...#."io.k8s.api.core.v1.EnvVar"]

		// List of sources to populate environment variables in the
		// container. The keys defined within a source must be a
		// C_IDENTIFIER. All invalid keys will be reported as an event
		// when the container is starting. When a key exists in multiple
		// sources, the value associated with the last source will take
		// precedence. Values defined by an Env with a duplicate key will
		// take precedence. Cannot be updated.
		"envFrom"?: [...#."io.k8s.api.core.v1.EnvFromSource"]

		// Container image name. More info:
		// https://kubernetes.io/docs/concepts/containers/images This
		// field is optional to allow higher level config management to
		// default or override container images in workload controllers
		// like Deployments and StatefulSets.
		"image"?: string

		// Image pull policy. One of Always, Never, IfNotPresent. Defaults
		// to Always if :latest tag is specified, or IfNotPresent
		// otherwise. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/containers/images#updating-images
		"imagePullPolicy"?: string

		// Actions that the management system should take in response to
		// container lifecycle events. Cannot be updated.
		"lifecycle"?: #."io.k8s.api.core.v1.Lifecycle"

		// Periodic probe of container liveness. Container will be
		// restarted if the probe fails. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"livenessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Name of the container specified as a DNS_LABEL. Each container
		// in a pod must have a unique name (DNS_LABEL). Cannot be
		// updated.
		"name"!: string

		// List of ports to expose from the container. Not specifying a
		// port here DOES NOT prevent that port from being exposed. Any
		// port which is listening on the default "0.0.0.0" address
		// inside a container will be accessible from the network.
		// Modifying this array with strategic merge patch may corrupt
		// the data. For more information See
		// https://github.com/kubernetes/kubernetes/issues/108255. Cannot
		// be updated.
		"ports"?: [...#."io.k8s.api.core.v1.ContainerPort"]

		// Periodic probe of container service readiness. Container will
		// be removed from service endpoints if the probe fails. Cannot
		// be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"readinessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Resources resize policy for the container.
		"resizePolicy"?: [...#."io.k8s.api.core.v1.ContainerResizePolicy"]

		// Compute Resources required by this container. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"resources"?: #."io.k8s.api.core.v1.ResourceRequirements"

		// RestartPolicy defines the restart behavior of individual
		// containers in a pod. This field may only be set for init
		// containers, and the only allowed value is "Always". For
		// non-init containers or when this field is not specified, the
		// restart behavior is defined by the Pod's restart policy and
		// the container type. Setting the RestartPolicy as "Always" for
		// the init container will have the following effect: this init
		// container will be continually restarted on exit until all
		// regular containers have terminated. Once all regular
		// containers have completed, all init containers with
		// restartPolicy "Always" will be shut down. This lifecycle
		// differs from normal init containers and is often referred to
		// as a "sidecar" container. Although this init container still
		// starts in the init container sequence, it does not wait for
		// the container to complete before proceeding to the next init
		// container. Instead, the next init container starts immediately
		// after this init container is started, or after any
		// startupProbe has successfully completed.
		"restartPolicy"?: string

		// SecurityContext defines the security options the container
		// should be run with. If set, the fields of SecurityContext
		// override the equivalent fields of PodSecurityContext. More
		// info:
		// https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
		"securityContext"?: #."io.k8s.api.core.v1.SecurityContext"

		// StartupProbe indicates that the Pod has successfully
		// initialized. If specified, no other probes are executed until
		// this completes successfully. If this probe fails, the Pod will
		// be restarted, just as if the livenessProbe failed. This can be
		// used to provide different probe parameters at the beginning of
		// a Pod's lifecycle, when it might take a long time to load data
		// or warm a cache, than during steady-state operation. This
		// cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"startupProbe"?: #."io.k8s.api.core.v1.Probe"

		// Whether this container should allocate a buffer for stdin in
		// the container runtime. If this is not set, reads from stdin in
		// the container will always result in EOF. Default is false.
		"stdin"?: bool

		// Whether the container runtime should close the stdin channel
		// after it has been opened by a single attach. When stdin is
		// true the stdin stream will remain open across multiple attach
		// sessions. If stdinOnce is set to true, stdin is opened on
		// container start, is empty until the first client attaches to
		// stdin, and then remains open and accepts data until the client
		// disconnects, at which time stdin is closed and remains closed
		// until the container is restarted. If this flag is false, a
		// container processes that reads from stdin will never receive
		// an EOF. Default is false
		"stdinOnce"?: bool

		// Optional: Path at which the file to which the container's
		// termination message will be written is mounted into the
		// container's filesystem. Message written is intended to be
		// brief final status, such as an assertion failure message. Will
		// be truncated by the node if greater than 4096 bytes. The total
		// message length across all containers will be limited to 12kb.
		// Defaults to /dev/termination-log. Cannot be updated.
		"terminationMessagePath"?: string

		// Indicate how the termination message should be populated. File
		// will use the contents of terminationMessagePath to populate
		// the container status message on both success and failure.
		// FallbackToLogsOnError will use the last chunk of container log
		// output if the termination message file is empty and the
		// container exited with an error. The log output is limited to
		// 2048 bytes or 80 lines, whichever is smaller. Defaults to
		// File. Cannot be updated.
		"terminationMessagePolicy"?: string

		// Whether this container should allocate a TTY for itself, also
		// requires 'stdin' to be true. Default is false.
		"tty"?: bool

		// volumeDevices is the list of block devices to be used by the
		// container.
		"volumeDevices"?: [...#."io.k8s.api.core.v1.VolumeDevice"]

		// Pod volumes to mount into the container's filesystem. Cannot be
		// updated.
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]

		// Container's working directory. If not specified, the container
		// runtime's default will be used, which might be configured in
		// the container image. Cannot be updated.
		"workingDir"?: string
	}

	// ContainerSetRetryStrategy provides controls on how to retry a
	// container set
	#: "io.argoproj.workflow.v1alpha1.ContainerSetRetryStrategy": {
		// Duration is the time between each retry, examples values are
		// "300ms", "1s" or "5m". Valid time units are "ns", "us" (or
		// "µs"), "ms", "s", "m", "h".
		"duration"?: string

		// Retries is the maximum number of retry attempts for each
		// container. It does not include the first, original attempt;
		// the maximum number of total attempts will be `retries + 1`.
		"retries"!: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"
	}

	#: "io.argoproj.workflow.v1alpha1.ContainerSetTemplate": {
		"containers"!: [...#."io.argoproj.workflow.v1alpha1.ContainerNode"]

		// RetryStrategy describes how to retry container nodes if the
		// container set fails. Note that this works differently from the
		// template-level `retryStrategy` as it is a process-level retry
		// that does not create new Pods or containers.
		"retryStrategy"?: #."io.argoproj.workflow.v1alpha1.ContainerSetRetryStrategy"
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]
	}

	// ContinueOn defines if a workflow should continue even if a task
	// or step fails/errors. It can be specified if the workflow
	// should continue when the pod errors, fails or both.
	#: "io.argoproj.workflow.v1alpha1.ContinueOn": {
		"error"?:  bool
		"failed"?: bool
	}

	// Counter is a Counter prometheus metric
	#: "io.argoproj.workflow.v1alpha1.Counter": {
		// Value is the value of the metric
		"value"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.CreateCronWorkflowRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"cronWorkflow"?:  #."io.argoproj.workflow.v1alpha1.CronWorkflow"
		"namespace"?:     string
	}

	// CreateS3BucketOptions options used to determine automatic
	// automatic bucket-creation process
	#: "io.argoproj.workflow.v1alpha1.CreateS3BucketOptions": {
		// ObjectLocking Enable object locking
		"objectLocking"?: bool
	}

	// CronWorkflow is the definition of a scheduled workflow resource
	#: "io.argoproj.workflow.v1alpha1.CronWorkflow": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: "argoproj.io/v1alpha1"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     "CronWorkflow"
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"!:     #."io.argoproj.workflow.v1alpha1.CronWorkflowSpec"
		"status"?:   #."io.argoproj.workflow.v1alpha1.CronWorkflowStatus"
	}

	#: "io.argoproj.workflow.v1alpha1.CronWorkflowDeletedResponse": {}

	// CronWorkflowList is list of CronWorkflow resources
	#: "io.argoproj.workflow.v1alpha1.CronWorkflowList": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string
		"items"!: [...#."io.argoproj.workflow.v1alpha1.CronWorkflow"]

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     string
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	#: "io.argoproj.workflow.v1alpha1.CronWorkflowResumeRequest": {
		"name"?:      string
		"namespace"?: string
	}

	// CronWorkflowSpec is the specification of a CronWorkflow
	#: "io.argoproj.workflow.v1alpha1.CronWorkflowSpec": {
		// ConcurrencyPolicy is the K8s-style concurrency policy that will
		// be used
		"concurrencyPolicy"?: string

		// FailedJobsHistoryLimit is the number of failed jobs to be kept
		// at a time
		"failedJobsHistoryLimit"?: int

		// v3.6 and after: Schedules is a list of schedules to run the
		// Workflow in Cron format
		"schedules"!: [...string]

		// StartingDeadlineSeconds is the K8s-style deadline that will
		// limit the time a CronWorkflow will be run after its original
		// scheduled time if it is missed.
		"startingDeadlineSeconds"?: int

		// v3.6 and after: StopStrategy defines if the CronWorkflow should
		// stop scheduling based on a condition
		"stopStrategy"?: #."io.argoproj.workflow.v1alpha1.StopStrategy"

		// SuccessfulJobsHistoryLimit is the number of successful jobs to
		// be kept at a time
		"successfulJobsHistoryLimit"?: int

		// Suspend is a flag that will stop new CronWorkflows from running
		// if set to true
		"suspend"?: bool

		// Timezone is the timezone against which the cron schedule will
		// be calculated, e.g. "Asia/Tokyo". Default is machine's local
		// time.
		"timezone"?: string

		// v3.6 and after: When is an expression that determines if a run
		// should be scheduled.
		"when"?: string

		// WorkflowMetadata contains some metadata of the workflow to be
		// run
		"workflowMetadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"

		// WorkflowSpec is the spec of the workflow to be run
		"workflowSpec"!: #."io.argoproj.workflow.v1alpha1.WorkflowSpec"
	}

	// CronWorkflowStatus is the status of a CronWorkflow
	#: "io.argoproj.workflow.v1alpha1.CronWorkflowStatus": {
		// Active is a list of active workflows stemming from this
		// CronWorkflow
		"active"?: [...#."io.k8s.api.core.v1.ObjectReference"]

		// Conditions is a list of conditions the CronWorkflow may have
		"conditions"?: [...#."io.argoproj.workflow.v1alpha1.Condition"]

		// v3.6 and after: Failed counts how many times child workflows
		// failed
		"failed"?: int

		// LastScheduleTime is the last time the CronWorkflow was
		// scheduled
		"lastScheduledTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// v3.6 and after: Phase is an enum of Active or Stopped. It
		// changes to Stopped when stopStrategy.expression is true
		"phase"?: string

		// v3.6 and after: Succeeded counts how many times child workflows
		// succeeded
		"succeeded"?: int
	}

	#: "io.argoproj.workflow.v1alpha1.CronWorkflowSuspendRequest": {
		"name"?:      string
		"namespace"?: string
	}

	// DAGTask represents a node in the graph during DAG execution
	// Note: CEL validation cannot check withItems (Schemaless) or
	// inline (PreserveUnknownFields) fields.
	#: "io.argoproj.workflow.v1alpha1.DAGTask": {
		// Arguments are the parameter and artifact arguments to the
		// template
		"arguments"?: #."io.argoproj.workflow.v1alpha1.Arguments"

		// ContinueOn makes argo to proceed with the following step even
		// if this step fails. Errors and Failed states can be specified
		"continueOn"?: #."io.argoproj.workflow.v1alpha1.ContinueOn"

		// Dependencies are name of other targets which this depends on
		"dependencies"?: [...string]

		// Depends are name of other targets which this depends on
		"depends"?: string

		// Hooks hold the lifecycle hook which is invoked at lifecycle of
		// task, irrespective of the success, failure, or error status of
		// the primary task
		"hooks"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.LifecycleHook"
		}

		// Inline is the template. Template must be empty if this is
		// declared (and vice-versa). Note: As mentioned in the
		// corresponding definition in WorkflowStep, this struct is
		// defined recursively, so we need
		// "x-kubernetes-preserve-unknown-fields: true" in the validation
		// schema.
		"inline"?: #."io.argoproj.workflow.v1alpha1.Template"

		// Name is the name of the target
		"name"!: string

		// OnExit is a template reference which is invoked at the end of
		// the template, irrespective of the success, failure, or error
		// of the primary template. DEPRECATED: Use Hooks[exit].Template
		// instead.
		"onExit"?: string

		// Name of template to execute
		"template"?: string

		// TemplateRef is the reference to the template resource to
		// execute.
		"templateRef"?: #."io.argoproj.workflow.v1alpha1.TemplateRef"

		// When is an expression in which the task should conditionally
		// execute
		"when"?: string

		// WithItems expands a task into multiple parallel tasks from the
		// items in the list Note: The structure of WithItems is
		// free-form, so we need "x-kubernetes-preserve-unknown-fields:
		// true" in the validation schema.
		"withItems"?: [...#."io.argoproj.workflow.v1alpha1.Item"]

		// WithParam expands a task into multiple parallel tasks from the
		// value in the parameter, which is expected to be a JSON list.
		"withParam"?: string

		// WithSequence expands a task into a numeric sequence
		"withSequence"?: #."io.argoproj.workflow.v1alpha1.Sequence"
	}

	// DAGTemplate is a template subtype for directed acyclic graph
	// templates
	#: "io.argoproj.workflow.v1alpha1.DAGTemplate": {
		// This flag is for DAG logic. The DAG logic has a built-in "fail
		// fast" feature to stop scheduling new steps, as soon as it
		// detects that one of the DAG nodes is failed. Then it waits
		// until all DAG nodes are completed before failing the DAG
		// itself. The FailFast flag default is true, if set to false, it
		// will allow a DAG to run all branches of the DAG to completion
		// (either success or failure), regardless of the failed outcomes
		// of branches in the DAG. More info and example about this
		// feature at
		// https://github.com/argoproj/argo-workflows/issues/1442
		"failFast"?: bool

		// Target are one or more names of targets to execute in a DAG
		"target"?: string

		// Tasks are a list of DAG tasks MaxItems is an artificial limit
		// to limit CEL validation costs - see note at top of file
		"tasks"!: [...#."io.argoproj.workflow.v1alpha1.DAGTask"]
	}

	// Data is a data template
	#: "io.argoproj.workflow.v1alpha1.Data": {
		// Source sources external data into a data template
		"source"!: #."io.argoproj.workflow.v1alpha1.DataSource"

		// Transformation applies a set of transformations
		"transformation"!: [...#."io.argoproj.workflow.v1alpha1.TransformationStep"]
	}

	// DataSource sources external data into a data template
	#: "io.argoproj.workflow.v1alpha1.DataSource": {
		// ArtifactPaths is a data transformation that collects a list of
		// artifact paths
		"artifactPaths"?: #."io.argoproj.workflow.v1alpha1.ArtifactPaths"
	}

	#: "io.argoproj.workflow.v1alpha1.Event": {
		// Selector (https://github.com/expr-lang/expr) that we must must
		// match the io.argoproj.workflow.v1alpha1. E.g. `payload.message
		// == "test"`
		"selector"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.EventResponse": {}

	// ExecutorConfig holds configurations of an executor container.
	#: "io.argoproj.workflow.v1alpha1.ExecutorConfig": {
		// ServiceAccountName specifies the service account name of the
		// executor container.
		"serviceAccountName"?: string
	}

	// GCSArtifact is the location of a GCS artifact
	#: "io.argoproj.workflow.v1alpha1.GCSArtifact": {
		// Bucket is the name of the bucket
		"bucket"?: string

		// Key is the path in the bucket where the artifact resides
		"key"!: string

		// ServiceAccountKeySecret is the secret selector to the bucket's
		// service account key
		"serviceAccountKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// GCSArtifactRepository defines the controller configuration for
	// a GCS artifact repository
	#: "io.argoproj.workflow.v1alpha1.GCSArtifactRepository": {
		// Bucket is the name of the bucket
		"bucket"?: string

		// KeyFormat defines the format of how to store keys and can
		// reference workflow variables.
		"keyFormat"?: string

		// ServiceAccountKeySecret is the secret selector to the bucket's
		// service account key
		"serviceAccountKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// Gauge is a Gauge prometheus metric
	#: "io.argoproj.workflow.v1alpha1.Gauge": {
		// Operation defines the operation to apply with value and the
		// metrics' current value
		"operation"?: string

		// Realtime emits this metric in real time if applicable
		"realtime"!: bool

		// Value is the value to be used in the operation with the
		// metric's current value. If no operation is set, value is the
		// value of the metric MaxLength is an artificial limit to limit
		// CEL validation costs - see note at top of file
		"value"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.GetUserInfoResponse": {
		"email"?:         string
		"emailVerified"?: bool
		"groups"?: [...string]
		"issuer"?:                  string
		"name"?:                    string
		"serviceAccountName"?:      string
		"serviceAccountNamespace"?: string
		"subject"?:                 string
	}

	// GitArtifact is the location of a git artifact
	#: "io.argoproj.workflow.v1alpha1.GitArtifact": {
		// Branch is the branch to fetch when `SingleBranch` is enabled
		"branch"?: string

		// Depth specifies clones/fetches should be shallow and include
		// the given number of commits from the branch tip
		"depth"?: int

		// DisableSubmodules disables submodules during git clone
		"disableSubmodules"?: bool

		// Fetch specifies a number of refs that should be fetched before
		// checkout
		"fetch"?: [...string]

		// InsecureIgnoreHostKey disables SSH strict host key checking
		// during git clone
		"insecureIgnoreHostKey"?: bool

		// InsecureSkipTLS disables server certificate verification
		// resulting in insecure HTTPS connections
		"insecureSkipTLS"?: bool

		// PasswordSecret is the secret selector to the repository
		// password
		"passwordSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Repo is the git repository
		"repo"!: string

		// Revision is the git commit, tag, branch to checkout
		"revision"?: string

		// SingleBranch enables single branch clone, using the `branch`
		// parameter
		"singleBranch"?: bool

		// SSHPrivateKeySecret is the secret selector to the repository
		// ssh private key
		"sshPrivateKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// UsernameSecret is the secret selector to the repository
		// username
		"usernameSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// HDFSArtifact is the location of an HDFS artifact
	#: "io.argoproj.workflow.v1alpha1.HDFSArtifact": {
		// Addresses is accessible addresses of HDFS name nodes
		"addresses"?: [...string]

		// DataTransferProtection is the protection level for HDFS data
		// transfer. It corresponds to the dfs.data.transfer.protection
		// configuration in HDFS.
		"dataTransferProtection"?: string

		// Force copies a file forcibly even if it exists
		"force"?: bool

		// HDFSUser is the user to access HDFS file system. It is ignored
		// if either ccache or keytab is used.
		"hdfsUser"?: string

		// KrbCCacheSecret is the secret selector for Kerberos ccache
		// Either ccache or keytab can be set to use Kerberos.
		"krbCCacheSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbConfig is the configmap selector for Kerberos config as
		// string It must be set if either ccache or keytab is used.
		"krbConfigConfigMap"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// KrbKeytabSecret is the secret selector for Kerberos keytab
		// Either ccache or keytab can be set to use Kerberos.
		"krbKeytabSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbRealm is the Kerberos realm used with Kerberos keytab It
		// must be set if keytab is used.
		"krbRealm"?: string

		// KrbServicePrincipalName is the principal name of Kerberos
		// service It must be set if either ccache or keytab is used.
		"krbServicePrincipalName"?: string

		// KrbUsername is the Kerberos username used with Kerberos keytab
		// It must be set if keytab is used.
		"krbUsername"?: string

		// Path is a file path in HDFS
		"path"!: string
	}

	// HDFSArtifactRepository defines the controller configuration for
	// an HDFS artifact repository
	#: "io.argoproj.workflow.v1alpha1.HDFSArtifactRepository": {
		// Addresses is accessible addresses of HDFS name nodes
		"addresses"?: [...string]

		// DataTransferProtection is the protection level for HDFS data
		// transfer. It corresponds to the dfs.data.transfer.protection
		// configuration in HDFS.
		"dataTransferProtection"?: string

		// Force copies a file forcibly even if it exists
		"force"?: bool

		// HDFSUser is the user to access HDFS file system. It is ignored
		// if either ccache or keytab is used.
		"hdfsUser"?: string

		// KrbCCacheSecret is the secret selector for Kerberos ccache
		// Either ccache or keytab can be set to use Kerberos.
		"krbCCacheSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbConfig is the configmap selector for Kerberos config as
		// string It must be set if either ccache or keytab is used.
		"krbConfigConfigMap"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// KrbKeytabSecret is the secret selector for Kerberos keytab
		// Either ccache or keytab can be set to use Kerberos.
		"krbKeytabSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// KrbRealm is the Kerberos realm used with Kerberos keytab It
		// must be set if keytab is used.
		"krbRealm"?: string

		// KrbServicePrincipalName is the principal name of Kerberos
		// service It must be set if either ccache or keytab is used.
		"krbServicePrincipalName"?: string

		// KrbUsername is the Kerberos username used with Kerberos keytab
		// It must be set if keytab is used.
		"krbUsername"?: string

		// PathFormat is defines the format of path to store a file. Can
		// reference workflow variables
		"pathFormat"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.HTTP": {
		// Body is content of the HTTP Request
		"body"?: string

		// BodyFrom is content of the HTTP Request as Bytes
		"bodyFrom"?: #."io.argoproj.workflow.v1alpha1.HTTPBodySource"

		// Headers are an optional list of headers to send with HTTP
		// requests
		"headers"?: [...#."io.argoproj.workflow.v1alpha1.HTTPHeader"]

		// InsecureSkipVerify is a bool when if set to true will skip TLS
		// verification for the HTTP client
		"insecureSkipVerify"?: bool

		// Method is HTTP methods for HTTP Request
		"method"?: string

		// SuccessCondition is an expression if evaluated to true is
		// considered successful
		"successCondition"?: string

		// TimeoutSeconds is request timeout for HTTP Request. Default is
		// 30 seconds
		"timeoutSeconds"?: int

		// URL of the HTTP Request
		"url"!: string
	}

	// HTTPArtifact allows a file served on HTTP to be placed as an
	// input artifact in a container
	#: "io.argoproj.workflow.v1alpha1.HTTPArtifact": {
		// Auth contains information for client authentication
		"auth"?: #."io.argoproj.workflow.v1alpha1.HTTPAuth"

		// Headers are an optional list of headers to send with HTTP
		// requests for artifacts
		"headers"?: [...#."io.argoproj.workflow.v1alpha1.Header"]

		// URL of the artifact
		"url"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.HTTPAuth": {
		"basicAuth"?:  #."io.argoproj.workflow.v1alpha1.BasicAuth"
		"clientCert"?: #."io.argoproj.workflow.v1alpha1.ClientCertAuth"
		"oauth2"?:     #."io.argoproj.workflow.v1alpha1.OAuth2Auth"
	}

	// HTTPBodySource contains the source of the HTTP body.
	#: "io.argoproj.workflow.v1alpha1.HTTPBodySource": "bytes"?: string

	#: "io.argoproj.workflow.v1alpha1.HTTPHeader": {
		"name"!:      string
		"value"?:     string
		"valueFrom"?: #."io.argoproj.workflow.v1alpha1.HTTPHeaderSource"
	}

	#: "io.argoproj.workflow.v1alpha1.HTTPHeaderSource": "secretKeyRef"?: #."io.k8s.api.core.v1.SecretKeySelector"

	// Header indicate a key-value request header to be used when
	// fetching artifacts over HTTP
	#: "io.argoproj.workflow.v1alpha1.Header": {
		// Name is the header name
		"name"!: string

		// Value is the literal value to use for the header
		"value"!: string
	}

	// Histogram is a Histogram prometheus metric
	#: "io.argoproj.workflow.v1alpha1.Histogram": {
		// Buckets is a list of bucket divisors for the histogram
		"buckets"!: [...#."io.argoproj.workflow.v1alpha1.Amount"]

		// Value is the value of the metric
		"value"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.InfoResponse": {
		"columns"?: [...#."io.argoproj.workflow.v1alpha1.Column"]
		"links"?: [...#."io.argoproj.workflow.v1alpha1.Link"]
		"managedNamespace"?: string

		// which modals to show
		"modals"?: {
			[string]: bool
		}
		"navColor"?: string
	}

	// Inputs are the mechanism for passing parameters, artifacts,
	// volumes from one template to another
	#: "io.argoproj.workflow.v1alpha1.Inputs": {
		// Artifact are a list of artifacts passed as inputs
		"artifacts"?: [...#."io.argoproj.workflow.v1alpha1.Artifact"]

		// Parameters are a list of parameters passed as inputs MaxItems
		// is an artificial limit to limit CEL validation costs - see
		// note at top of file
		"parameters"?: [...#."io.argoproj.workflow.v1alpha1.Parameter"]
	}

	// Item expands a single workflow step into multiple parallel
	// steps The value of Item can be a map, string, bool, or number
	#: "io.argoproj.workflow.v1alpha1.Item": _

	// LabelKeys is list of keys
	#: "io.argoproj.workflow.v1alpha1.LabelKeys": "items"?: [...string]

	#: "io.argoproj.workflow.v1alpha1.LabelValueFrom": "expression"!: string

	// Labels is list of workflow labels
	#: "io.argoproj.workflow.v1alpha1.LabelValues": "items"?: [...string]

	#: "io.argoproj.workflow.v1alpha1.LifecycleHook": {
		// Arguments hold arguments to the template
		"arguments"?: #."io.argoproj.workflow.v1alpha1.Arguments"

		// Expression is a condition expression for when a node will be
		// retried. If it evaluates to false, the node will not be
		// retried and the retry strategy will be ignored
		"expression"?: string

		// Template is the name of the template to execute by the hook
		"template"?: string

		// TemplateRef is the reference to the template resource to
		// execute by the hook
		"templateRef"?: #."io.argoproj.workflow.v1alpha1.TemplateRef"
	}

	// A link to another app.
	#: "io.argoproj.workflow.v1alpha1.Link": {
		// The name of the link, E.g. "Workflow Logs" or "Pod Logs"
		"name"!: string

		// "workflow", "pod", "pod-logs", "event-source-logs",
		// "sensor-logs", "workflow-list" or "chat"
		"scope"!: string

		// Target attribute specifies where a linked document will be
		// opened when a user clicks on a link. E.g. "_blank", "_self".
		// If the target is _blank, it will open in a new tab.
		"target"!: string

		// The URL. Can contain "${metadata.namespace}",
		// "${metadata.name}", "${status.startedAt}",
		// "${status.finishedAt}" or any other element in workflow yaml,
		// e.g.
		// "${io.argoproj.workflow.v1alpha1.metadata.annotations.userDefinedKey}"
		"url"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.LintCronWorkflowRequest": {
		"cronWorkflow"?: #."io.argoproj.workflow.v1alpha1.CronWorkflow"
		"namespace"?:    string
	}

	#: "io.argoproj.workflow.v1alpha1.LogEntry": {
		"content"?: string
		"podName"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.ManifestFrom": {
		// Artifact contains the artifact to use
		"artifact"!: #."io.argoproj.workflow.v1alpha1.Artifact"
	}

	// MemoizationStatus is the status of this memoized node
	#: "io.argoproj.workflow.v1alpha1.MemoizationStatus": {
		// Cache is the name of the cache that was used
		"cacheName"!: string

		// Hit indicates whether this node was created from a cache entry
		"hit"!: bool

		// Key is the name of the key used for this node's cache
		"key"!: string
	}

	// Memoization enables caching for the Outputs of the template
	#: "io.argoproj.workflow.v1alpha1.Memoize": {
		// Cache sets and configures the kind of cache
		"cache"!: #."io.argoproj.workflow.v1alpha1.Cache"

		// Key is the key to use as the caching key
		"key"!: string

		// MaxAge is the maximum age (e.g. "180s", "24h") of an entry that
		// is still considered valid. If an entry is older than the
		// MaxAge, it will be ignored.
		"maxAge"!: string
	}

	// Pod metadata
	#: "io.argoproj.workflow.v1alpha1.Metadata": {
		"annotations"?: [string]: string
		"labels"?: {
			[string]: string
		}
	}

	// MetricLabel is a single label for a prometheus metric
	#: "io.argoproj.workflow.v1alpha1.MetricLabel": {
		"key"!:   string
		"value"!: string
	}

	// Metrics are a list of metrics emitted from a Workflow/Template
	#: "io.argoproj.workflow.v1alpha1.Metrics": {
		// Prometheus is a list of prometheus metrics to be emitted
		// MaxItems is an artificial limit to limit CEL validation costs
		// - see note at top of file
		"prometheus"!: [...#."io.argoproj.workflow.v1alpha1.Prometheus"]
	}

	// Mutex holds Mutex configuration
	#: "io.argoproj.workflow.v1alpha1.Mutex": {
		// Database specifies this is database controlled if this is set
		// true
		"database"?: bool

		// name of the mutex
		"name"?: string

		// Namespace is the namespace of the mutex, default: [namespace of
		// workflow]
		"namespace"?: string
	}

	// MutexHolding describes the mutex and the object which is
	// holding it.
	#: "io.argoproj.workflow.v1alpha1.MutexHolding": {
		// Holder is a reference to the object which holds the Mutex.
		// Holding Scenario:
		// 1. Current workflow's NodeID which is holding the lock.
		// e.g: ${NodeID}
		// Waiting Scenario:
		// 1. Current workflow or other workflow NodeID which is holding
		// the lock.
		// e.g: ${WorkflowName}/${NodeID}
		"holder"?: string

		// Reference for the mutex e.g: ${namespace}/mutex/${mutexName}
		"mutex"?: string
	}

	// MutexStatus contains which objects hold mutex locks, and which
	// objects this workflow is waiting on to release locks.
	#: "io.argoproj.workflow.v1alpha1.MutexStatus": {
		// Holding is a list of mutexes and their respective objects that
		// are held by mutex lock for this io.argoproj.workflow.v1alpha1.
		"holding"?: [...#."io.argoproj.workflow.v1alpha1.MutexHolding"]

		// Waiting is a list of mutexes and their respective objects this
		// workflow is waiting for.
		"waiting"?: [...#."io.argoproj.workflow.v1alpha1.MutexHolding"]
	}

	#: "io.argoproj.workflow.v1alpha1.NodeFlag": {
		// Hooked tracks whether or not this node was triggered by hook or
		// onExit
		"hooked"?: bool

		// Retried tracks whether or not this node was retried by
		// retryStrategy
		"retried"?: bool
	}

	// NodeStatus contains status information about an individual node
	// in the workflow
	#: "io.argoproj.workflow.v1alpha1.NodeStatus": {
		// BoundaryID indicates the node ID of the associated template
		// root node in which this node belongs to
		"boundaryID"?: string

		// Children is a list of child node IDs
		"children"?: [...string]

		// Daemoned tracks whether or not this node was daemoned and need
		// to be terminated
		"daemoned"?: bool

		// DisplayName is a human readable representation of the node.
		// Unique within a template boundary
		"displayName"?: string

		// EstimatedDuration in seconds.
		"estimatedDuration"?: int

		// FailedPodRestarts tracks the number of times the pod for this
		// node was restarted due to infrastructure failures before the
		// main container started.
		"failedPodRestarts"?: int

		// Time at which this node completed
		"finishedAt"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// HostNodeName name of the Kubernetes node on which the Pod is
		// running, if applicable
		"hostNodeName"?: string

		// ID is a unique identifier of a node within the worklow It is
		// implemented as a hash of the node name, which makes the ID
		// deterministic
		"id"!: string

		// Inputs captures input parameter values and artifact locations
		// supplied to this template invocation
		"inputs"?: #."io.argoproj.workflow.v1alpha1.Inputs"

		// MemoizationStatus holds information about cached nodes
		"memoizationStatus"?: #."io.argoproj.workflow.v1alpha1.MemoizationStatus"

		// A human readable message indicating details about why the node
		// is in this condition.
		"message"?: string

		// Name is unique name in the node tree used to generate the node
		// ID
		"name"!: string

		// NodeFlag tracks some history of node. e.g.) hooked, retried,
		// etc.
		"nodeFlag"?: #."io.argoproj.workflow.v1alpha1.NodeFlag"

		// OutboundNodes tracks the node IDs which are considered
		// "outbound" nodes to a template invocation. For every
		// invocation of a template, there are nodes which we considered
		// as "outbound". Essentially, these are last nodes in the
		// execution sequence to run, before the template is considered
		// completed. These nodes are then connected as parents to a
		// following step.
		//
		// In the case of single pod steps (i.e. container, script,
		// resource templates), this list will be nil since the pod
		// itself is already considered the "outbound" node. In the case
		// of DAGs, outbound nodes are the "target" tasks (tasks with no
		// children). In the case of steps, outbound nodes are all the
		// containers involved in the last step group. NOTE: since
		// templates are composable, the list of outbound nodes are
		// carried upwards when a DAG/steps template invokes another
		// DAG/steps template. In other words, the outbound nodes of a
		// template, will be a superset of the outbound nodes of its last
		// children.
		"outboundNodes"?: [...string]

		// Outputs captures output parameter values and artifact locations
		// produced by this template invocation
		"outputs"?: #."io.argoproj.workflow.v1alpha1.Outputs"

		// Phase a simple, high-level summary of where the node is in its
		// lifecycle. Can be used as a state machine. Will be one of
		// these values "Pending", "Running" before the node is
		// completed, or "Succeeded", "Skipped", "Failed", "Error", or
		// "Omitted" as a final state.
		"phase"?: string

		// PodIP captures the IP of the pod for daemoned steps
		"podIP"?: string

		// Progress to completion
		"progress"?: string

		// ResourcesDuration is indicative, but not accurate, resource
		// duration. This is populated when the nodes completes.
		"resourcesDuration"?: {
			[string]: int
		}

		// RestartingPodUID tracks the UID of the pod that is currently
		// being restarted. This prevents duplicate restart attempts when
		// the controller processes the same failed pod multiple times.
		// Cleared when the replacement pod starts running.
		"restartingPodUID"?: string

		// Time at which this node started
		"startedAt"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// SynchronizationStatus is the synchronization status of the node
		"synchronizationStatus"?: #."io.argoproj.workflow.v1alpha1.NodeSynchronizationStatus"

		// TaskResultSynced is used to determine if the node's output has
		// been received
		"taskResultSynced"?: bool

		// TemplateName is the template name which this node corresponds
		// to. Not applicable to virtual nodes (e.g. Retry, StepGroup)
		"templateName"?: string

		// TemplateRef is the reference to the template resource which
		// this node corresponds to. Not applicable to virtual nodes
		// (e.g. Retry, StepGroup)
		"templateRef"?: #."io.argoproj.workflow.v1alpha1.TemplateRef"

		// TemplateScope is the template scope in which the template of
		// this node was retrieved.
		"templateScope"?: string

		// Type indicates type of node
		"type"!: string
	}

	// NodeSynchronizationStatus stores the status of a node
	#: "io.argoproj.workflow.v1alpha1.NodeSynchronizationStatus": {
		// Waiting is the name of the lock that this node is waiting for
		"waiting"?: string
	}

	// NoneStrategy indicates to skip tar process and upload the files
	// or directory tree as independent files. Note that if the
	// artifact is a directory, the artifact driver must support the
	// ability to save/load the directory appropriately.
	#: "io.argoproj.workflow.v1alpha1.NoneStrategy": {}

	// OAuth2Auth holds all information for client authentication via
	// OAuth2 tokens
	#: "io.argoproj.workflow.v1alpha1.OAuth2Auth": {
		"clientIDSecret"?:     #."io.k8s.api.core.v1.SecretKeySelector"
		"clientSecretSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
		"endpointParams"?: [...#."io.argoproj.workflow.v1alpha1.OAuth2EndpointParam"]
		"scopes"?: [...string]
		"tokenURLSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// EndpointParam is for requesting optional fields that should be
	// sent in the oauth request
	#: "io.argoproj.workflow.v1alpha1.OAuth2EndpointParam": {
		// Name is the header name
		"key"!: string

		// Value is the literal value to use for the header
		"value"?: string
	}

	// OSSArtifact is the location of an Alibaba Cloud OSS artifact
	#: "io.argoproj.workflow.v1alpha1.OSSArtifact": {
		// AccessKeySecret is the secret selector to the bucket's access
		// key
		"accessKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Bucket is the name of the bucket
		"bucket"?: string

		// CreateBucketIfNotPresent tells the driver to attempt to create
		// the OSS bucket for output artifacts, if it doesn't exist
		"createBucketIfNotPresent"?: bool

		// Endpoint is the hostname of the bucket endpoint
		"endpoint"?: string

		// Key is the path in the bucket where the artifact resides
		"key"!: string

		// LifecycleRule specifies how to manage bucket's lifecycle
		"lifecycleRule"?: #."io.argoproj.workflow.v1alpha1.OSSLifecycleRule"

		// SecretKeySecret is the secret selector to the bucket's secret
		// key
		"secretKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SecurityToken is the user's temporary security token. For more
		// details, check out:
		// https://www.alibabacloud.com/help/doc-detail/100624.htm
		"securityToken"?: string

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// OSSArtifactRepository defines the controller configuration for
	// an OSS artifact repository
	#: "io.argoproj.workflow.v1alpha1.OSSArtifactRepository": {
		// AccessKeySecret is the secret selector to the bucket's access
		// key
		"accessKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Bucket is the name of the bucket
		"bucket"?: string

		// CreateBucketIfNotPresent tells the driver to attempt to create
		// the OSS bucket for output artifacts, if it doesn't exist
		"createBucketIfNotPresent"?: bool

		// Endpoint is the hostname of the bucket endpoint
		"endpoint"?: string

		// KeyFormat defines the format of how to store keys and can
		// reference workflow variables.
		"keyFormat"?: string

		// LifecycleRule specifies how to manage bucket's lifecycle
		"lifecycleRule"?: #."io.argoproj.workflow.v1alpha1.OSSLifecycleRule"

		// SecretKeySecret is the secret selector to the bucket's secret
		// key
		"secretKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SecurityToken is the user's temporary security token. For more
		// details, check out:
		// https://www.alibabacloud.com/help/doc-detail/100624.htm
		"securityToken"?: string

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// OSSLifecycleRule specifies how to manage bucket's lifecycle
	#: "io.argoproj.workflow.v1alpha1.OSSLifecycleRule": {
		// MarkDeletionAfterDays is the number of days before we delete
		// objects in the bucket
		"markDeletionAfterDays"?: int

		// MarkInfrequentAccessAfterDays is the number of days before we
		// convert the objects in the bucket to Infrequent Access (IA)
		// storage type
		"markInfrequentAccessAfterDays"?: int
	}

	// Outputs hold parameters, artifacts, and results from a step
	#: "io.argoproj.workflow.v1alpha1.Outputs": {
		// Artifacts holds the list of output artifacts produced by a step
		"artifacts"?: [...#."io.argoproj.workflow.v1alpha1.Artifact"]

		// ExitCode holds the exit code of a script template
		"exitCode"?: string

		// Parameters holds the list of output parameters produced by a
		// step
		"parameters"?: [...#."io.argoproj.workflow.v1alpha1.Parameter"]

		// Result holds the result (stdout) of a script or container
		// template, or the response body of an HTTP template
		"result"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.ParallelSteps": [...#."io.argoproj.workflow.v1alpha1.WorkflowStep"]

	// Parameter indicate a passed string parameter to a service
	// template with an optional default value
	#: "io.argoproj.workflow.v1alpha1.Parameter": {
		// Default is the default value to use for an input parameter if a
		// value was not supplied
		"default"?: string

		// Description is the parameter description
		"description"?: string

		// Enum holds a list of string values to choose from, for the
		// actual value of the parameter
		"enum"?: [...string]

		// GlobalName exports an output parameter to the global scope,
		// making it available as
		// '{{io.argoproj.workflow.v1alpha1.outputs.parameters.XXXX}} and
		// in workflow.status.outputs.parameters
		"globalName"?: string

		// Name is the parameter name
		"name"!: string

		// Value is the literal value to use for the parameter. If
		// specified in the context of an input parameter, any passed
		// values take precedence over the specified value
		"value"?: string

		// ValueFrom is the source for the output parameter's value
		"valueFrom"?: #."io.argoproj.workflow.v1alpha1.ValueFrom"
	}

	// Plugin is an Object with exactly one key
	#: "io.argoproj.workflow.v1alpha1.Plugin": {}

	// PluginArtifact is the location of a plugin artifact
	#: "io.argoproj.workflow.v1alpha1.PluginArtifact": {
		// Configuration is the plugin defined configuration for the
		// artifact driver plugin
		"configuration"?: string

		// ConnectionTimeoutSeconds is the timeout for the artifact driver
		// connection, overriding the driver's timeout
		"connectionTimeoutSeconds"?: int

		// Key is the path in the artifact repository where the artifact
		// resides
		"key"!: string

		// Name is the name of the artifact driver plugin
		"name"?: string
	}

	// PluginArtifactRepository defines the controller configuration
	// for a plugin artifact repository
	#: "io.argoproj.workflow.v1alpha1.PluginArtifactRepository": {
		"configuration"!: string
		"keyFormat"?:     string
		"name"!:          string
	}

	// PodGC describes how to delete completed pods as they complete
	#: "io.argoproj.workflow.v1alpha1.PodGC": {
		// DeleteDelayDuration specifies the duration before pods in the
		// GC queue get deleted.
		"deleteDelayDuration"?: string

		// LabelSelector is the label selector to check if the pods match
		// the labels before being added to the pod GC queue.
		"labelSelector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// Strategy is the strategy to use. One of "OnPodCompletion",
		// "OnPodSuccess", "OnWorkflowCompletion", "OnWorkflowSuccess".
		// If unset, does not delete Pods
		"strategy"?: string
	}

	// Prometheus is a prometheus metric to be emitted
	#: "io.argoproj.workflow.v1alpha1.Prometheus": {
		// Counter is a counter metric
		"counter"?: #."io.argoproj.workflow.v1alpha1.Counter"

		// Gauge is a gauge metric
		"gauge"?: #."io.argoproj.workflow.v1alpha1.Gauge"

		// Help is a string that describes the metric
		"help"!: string

		// Histogram is a histogram metric
		"histogram"?: #."io.argoproj.workflow.v1alpha1.Histogram"

		// Labels is a list of metric labels
		"labels"?: [...#."io.argoproj.workflow.v1alpha1.MetricLabel"]

		// Name is the name of the metric
		"name"!: string

		// When is a conditional statement that decides when to emit the
		// metric
		"when"?: string
	}

	// RawArtifact allows raw string content to be placed as an
	// artifact in a container
	#: "io.argoproj.workflow.v1alpha1.RawArtifact": {
		// Data is the string contents of the artifact
		"data"!: string
	}

	// ResourceTemplate is a template subtype to manipulate kubernetes
	// resources
	#: "io.argoproj.workflow.v1alpha1.ResourceTemplate": {
		// Action is the action to perform to the resource. Must be one
		// of: get, create, apply, delete, replace, patch
		"action"!: string

		// FailureCondition is a label selector expression which describes
		// the conditions of the k8s resource in which the step was
		// considered failed
		"failureCondition"?: string

		// Flags is a set of additional options passed to kubectl before
		// submitting a resource I.e. to disable resource validation:
		// flags: [
		// "--validate=false" # disable resource validation
		// ]
		"flags"?: [...string]

		// Manifest contains the kubernetes manifest
		"manifest"?: string

		// ManifestFrom is the source for a single kubernetes manifest
		"manifestFrom"?: #."io.argoproj.workflow.v1alpha1.ManifestFrom"

		// MergeStrategy is the strategy used to merge a patch. It
		// defaults to "strategic" Must be one of: strategic, merge, json
		"mergeStrategy"?: string

		// SetOwnerReference sets the reference to the workflow on the
		// OwnerReference of generated resource.
		"setOwnerReference"?: bool

		// SuccessCondition is a label selector expression which describes
		// the conditions of the k8s resource in which it is acceptable
		// to proceed to the following step
		"successCondition"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.ResubmitArchivedWorkflowRequest": {
		"memoized"?:  bool
		"name"?:      string
		"namespace"?: string
		"parameters"?: [...string]
		"uid"?: string
	}

	// RetryAffinity prevents running steps on the same host.
	#: "io.argoproj.workflow.v1alpha1.RetryAffinity": "nodeAntiAffinity"?: #."io.argoproj.workflow.v1alpha1.RetryNodeAntiAffinity"

	#: "io.argoproj.workflow.v1alpha1.RetryArchivedWorkflowRequest": {
		"name"?:              string
		"namespace"?:         string
		"nodeFieldSelector"?: string
		"parameters"?: [...string]
		"restartSuccessful"?: bool
		"uid"?:               string
	}

	// RetryNodeAntiAffinity is a placeholder for future expansion,
	// only empty nodeAntiAffinity is allowed. In order to prevent
	// running steps on the same host, it uses
	// "kubernetes.io/hostname".
	#: "io.argoproj.workflow.v1alpha1.RetryNodeAntiAffinity": {}

	// RetryStrategy provides controls on how to retry a workflow step
	#: "io.argoproj.workflow.v1alpha1.RetryStrategy": {
		// Affinity prevents running workflow's step on the same host
		"affinity"?: #."io.argoproj.workflow.v1alpha1.RetryAffinity"

		// Backoff is a backoff strategy
		"backoff"?: #."io.argoproj.workflow.v1alpha1.Backoff"

		// Expression is a condition expression for when a node will be
		// retried. If it evaluates to false, the node will not be
		// retried and the retry strategy will be ignored
		"expression"?: string

		// Limit is the maximum number of retry attempts when retrying a
		// container. It does not include the original container; the
		// maximum number of total attempts will be `limit + 1`.
		"limit"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// RetryPolicy is a policy of NodePhase statuses that will be
		// retried
		"retryPolicy"?: string
	}

	// S3Artifact is the location of an S3 artifact
	#: "io.argoproj.workflow.v1alpha1.S3Artifact": {
		// AccessKeySecret is the secret selector to the bucket's access
		// key
		"accessKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Bucket is the name of the bucket
		"bucket"?: string

		// CASecret specifies the secret that contains the CA, used to
		// verify the TLS connection
		"caSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// CreateBucketIfNotPresent tells the driver to attempt to create
		// the S3 bucket for output artifacts, if it doesn't exist.
		// Setting Enabled Encryption will apply either SSE-S3 to the
		// bucket if KmsKeyId is not set or SSE-KMS if it is.
		"createBucketIfNotPresent"?: #."io.argoproj.workflow.v1alpha1.CreateS3BucketOptions"
		"encryptionOptions"?:        #."io.argoproj.workflow.v1alpha1.S3EncryptionOptions"

		// Endpoint is the hostname of the bucket endpoint
		"endpoint"?: string

		// Insecure will connect to the service with TLS
		"insecure"?: bool

		// Key is the key in the bucket where the artifact resides
		"key"?: string

		// Region contains the optional bucket region
		"region"?: string

		// RoleARN is the Amazon Resource Name (ARN) of the role to
		// assume.
		"roleARN"?: string

		// SecretKeySecret is the secret selector to the bucket's secret
		// key
		"secretKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SessionTokenSecret is used for ephemeral credentials like an
		// IAM assume role or S3 access grant
		"sessionTokenSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// S3ArtifactRepository defines the controller configuration for
	// an S3 artifact repository
	#: "io.argoproj.workflow.v1alpha1.S3ArtifactRepository": {
		// AccessKeySecret is the secret selector to the bucket's access
		// key
		"accessKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// Bucket is the name of the bucket
		"bucket"?: string

		// CASecret specifies the secret that contains the CA, used to
		// verify the TLS connection
		"caSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// CreateBucketIfNotPresent tells the driver to attempt to create
		// the S3 bucket for output artifacts, if it doesn't exist.
		// Setting Enabled Encryption will apply either SSE-S3 to the
		// bucket if KmsKeyId is not set or SSE-KMS if it is.
		"createBucketIfNotPresent"?: #."io.argoproj.workflow.v1alpha1.CreateS3BucketOptions"
		"encryptionOptions"?:        #."io.argoproj.workflow.v1alpha1.S3EncryptionOptions"

		// Endpoint is the hostname of the bucket endpoint
		"endpoint"?: string

		// Insecure will connect to the service with TLS
		"insecure"?: bool

		// KeyFormat defines the format of how to store keys and can
		// reference workflow variables.
		"keyFormat"?: string

		// KeyPrefix is prefix used as part of the bucket key in which the
		// controller will store artifacts. DEPRECATED. Use KeyFormat
		// instead
		"keyPrefix"?: string

		// Region contains the optional bucket region
		"region"?: string

		// RoleARN is the Amazon Resource Name (ARN) of the role to
		// assume.
		"roleARN"?: string

		// SecretKeySecret is the secret selector to the bucket's secret
		// key
		"secretKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// SessionTokenSecret is used for ephemeral credentials like an
		// IAM assume role or S3 access grant
		"sessionTokenSecret"?: #."io.k8s.api.core.v1.SecretKeySelector"

		// UseSDKCreds tells the driver to figure out credentials based on
		// sdk defaults.
		"useSDKCreds"?: bool
	}

	// S3EncryptionOptions used to determine encryption options during
	// s3 operations
	#: "io.argoproj.workflow.v1alpha1.S3EncryptionOptions": {
		// EnableEncryption tells the driver to encrypt objects if set to
		// true. If kmsKeyId and serverSideCustomerKeySecret are not set,
		// SSE-S3 will be used
		"enableEncryption"?: bool

		// KmsEncryptionContext is a json blob that contains an encryption
		// context. See
		// https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#encrypt_context
		// for more information
		"kmsEncryptionContext"?: string

		// KMSKeyId tells the driver to encrypt the object using the
		// specified KMS Key.
		"kmsKeyId"?: string

		// ServerSideCustomerKeySecret tells the driver to encrypt the
		// output artifacts using SSE-C with the specified secret.
		"serverSideCustomerKeySecret"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// ScriptTemplate is a template subtype to enable scripting
	// through code steps
	#: "io.argoproj.workflow.v1alpha1.ScriptTemplate": {
		// Arguments to the entrypoint. The container image's CMD is used
		// if this is not provided. Variable references $(VAR_NAME) are
		// expanded using the container's environment. If a variable
		// cannot be resolved, the reference in the input string will be
		// unchanged. Double $$ are reduced to a single $, which allows
		// for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will
		// produce the string literal "$(VAR_NAME)". Escaped references
		// will never be expanded, regardless of whether the variable
		// exists or not. Cannot be updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"args"?: [...string]

		// Entrypoint array. Not executed within a shell. The container
		// image's ENTRYPOINT is used if this is not provided. Variable
		// references $(VAR_NAME) are expanded using the container's
		// environment. If a variable cannot be resolved, the reference
		// in the input string will be unchanged. Double $$ are reduced
		// to a single $, which allows for escaping the $(VAR_NAME)
		// syntax: i.e. "$$(VAR_NAME)" will produce the string literal
		// "$(VAR_NAME)". Escaped references will never be expanded,
		// regardless of whether the variable exists or not. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"command"?: [...string]

		// List of environment variables to set in the container. Cannot
		// be updated.
		"env"?: [...#."io.k8s.api.core.v1.EnvVar"]

		// List of sources to populate environment variables in the
		// container. The keys defined within a source must be a
		// C_IDENTIFIER. All invalid keys will be reported as an event
		// when the container is starting. When a key exists in multiple
		// sources, the value associated with the last source will take
		// precedence. Values defined by an Env with a duplicate key will
		// take precedence. Cannot be updated.
		"envFrom"?: [...#."io.k8s.api.core.v1.EnvFromSource"]

		// Container image name. More info:
		// https://kubernetes.io/docs/concepts/containers/images This
		// field is optional to allow higher level config management to
		// default or override container images in workload controllers
		// like Deployments and StatefulSets.
		"image"!: string

		// Image pull policy. One of Always, Never, IfNotPresent. Defaults
		// to Always if :latest tag is specified, or IfNotPresent
		// otherwise. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/containers/images#updating-images
		"imagePullPolicy"?: string

		// Actions that the management system should take in response to
		// container lifecycle events. Cannot be updated.
		"lifecycle"?: #."io.k8s.api.core.v1.Lifecycle"

		// Periodic probe of container liveness. Container will be
		// restarted if the probe fails. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"livenessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Name of the container specified as a DNS_LABEL. Each container
		// in a pod must have a unique name (DNS_LABEL). Cannot be
		// updated.
		"name"?: string

		// List of ports to expose from the container. Not specifying a
		// port here DOES NOT prevent that port from being exposed. Any
		// port which is listening on the default "0.0.0.0" address
		// inside a container will be accessible from the network.
		// Modifying this array with strategic merge patch may corrupt
		// the data. For more information See
		// https://github.com/kubernetes/kubernetes/issues/108255. Cannot
		// be updated.
		"ports"?: [...#."io.k8s.api.core.v1.ContainerPort"]

		// Periodic probe of container service readiness. Container will
		// be removed from service endpoints if the probe fails. Cannot
		// be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"readinessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Resources resize policy for the container.
		"resizePolicy"?: [...#."io.k8s.api.core.v1.ContainerResizePolicy"]

		// Compute Resources required by this container. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"resources"?: #."io.k8s.api.core.v1.ResourceRequirements"

		// RestartPolicy defines the restart behavior of individual
		// containers in a pod. This field may only be set for init
		// containers, and the only allowed value is "Always". For
		// non-init containers or when this field is not specified, the
		// restart behavior is defined by the Pod's restart policy and
		// the container type. Setting the RestartPolicy as "Always" for
		// the init container will have the following effect: this init
		// container will be continually restarted on exit until all
		// regular containers have terminated. Once all regular
		// containers have completed, all init containers with
		// restartPolicy "Always" will be shut down. This lifecycle
		// differs from normal init containers and is often referred to
		// as a "sidecar" container. Although this init container still
		// starts in the init container sequence, it does not wait for
		// the container to complete before proceeding to the next init
		// container. Instead, the next init container starts immediately
		// after this init container is started, or after any
		// startupProbe has successfully completed.
		"restartPolicy"?: string

		// SecurityContext defines the security options the container
		// should be run with. If set, the fields of SecurityContext
		// override the equivalent fields of PodSecurityContext. More
		// info:
		// https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
		"securityContext"?: #."io.k8s.api.core.v1.SecurityContext"

		// Source contains the source code of the script to execute
		"source"!: string

		// StartupProbe indicates that the Pod has successfully
		// initialized. If specified, no other probes are executed until
		// this completes successfully. If this probe fails, the Pod will
		// be restarted, just as if the livenessProbe failed. This can be
		// used to provide different probe parameters at the beginning of
		// a Pod's lifecycle, when it might take a long time to load data
		// or warm a cache, than during steady-state operation. This
		// cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"startupProbe"?: #."io.k8s.api.core.v1.Probe"

		// Whether this container should allocate a buffer for stdin in
		// the container runtime. If this is not set, reads from stdin in
		// the container will always result in EOF. Default is false.
		"stdin"?: bool

		// Whether the container runtime should close the stdin channel
		// after it has been opened by a single attach. When stdin is
		// true the stdin stream will remain open across multiple attach
		// sessions. If stdinOnce is set to true, stdin is opened on
		// container start, is empty until the first client attaches to
		// stdin, and then remains open and accepts data until the client
		// disconnects, at which time stdin is closed and remains closed
		// until the container is restarted. If this flag is false, a
		// container processes that reads from stdin will never receive
		// an EOF. Default is false
		"stdinOnce"?: bool

		// Optional: Path at which the file to which the container's
		// termination message will be written is mounted into the
		// container's filesystem. Message written is intended to be
		// brief final status, such as an assertion failure message. Will
		// be truncated by the node if greater than 4096 bytes. The total
		// message length across all containers will be limited to 12kb.
		// Defaults to /dev/termination-log. Cannot be updated.
		"terminationMessagePath"?: string

		// Indicate how the termination message should be populated. File
		// will use the contents of terminationMessagePath to populate
		// the container status message on both success and failure.
		// FallbackToLogsOnError will use the last chunk of container log
		// output if the termination message file is empty and the
		// container exited with an error. The log output is limited to
		// 2048 bytes or 80 lines, whichever is smaller. Defaults to
		// File. Cannot be updated.
		"terminationMessagePolicy"?: string

		// Whether this container should allocate a TTY for itself, also
		// requires 'stdin' to be true. Default is false.
		"tty"?: bool

		// volumeDevices is the list of block devices to be used by the
		// container.
		"volumeDevices"?: [...#."io.k8s.api.core.v1.VolumeDevice"]

		// Pod volumes to mount into the container's filesystem. Cannot be
		// updated.
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]

		// Container's working directory. If not specified, the container
		// runtime's default will be used, which might be configured in
		// the container image. Cannot be updated.
		"workingDir"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.SemaphoreHolding": {
		// Holders stores the list of current holder names in the
		// io.argoproj.workflow.v1alpha1.
		"holders"?: [...string]

		// Semaphore stores the semaphore name.
		"semaphore"?: string
	}

	// SemaphoreRef is a reference of Semaphore
	#: "io.argoproj.workflow.v1alpha1.SemaphoreRef": {
		// ConfigMapKeyRef is a configmap selector for Semaphore
		// configuration
		"configMapKeyRef"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// SyncDatabaseRef is a database reference for Semaphore
		// configuration
		"database"?: #."io.argoproj.workflow.v1alpha1.SyncDatabaseRef"

		// Namespace is the namespace of the configmap, default:
		// [namespace of workflow]
		"namespace"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.SemaphoreStatus": {
		// Holding stores the list of resource acquired synchronization
		// lock for workflows.
		"holding"?: [...#."io.argoproj.workflow.v1alpha1.SemaphoreHolding"]

		// Waiting indicates the list of current synchronization lock
		// holders.
		"waiting"?: [...#."io.argoproj.workflow.v1alpha1.SemaphoreHolding"]
	}

	// Sequence expands a workflow step into numeric range
	#: "io.argoproj.workflow.v1alpha1.Sequence": {
		// Count is number of elements in the sequence (default: 0). Not
		// to be used with end
		"count"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// Number at which to end the sequence (default: 0). Not to be
		// used with Count
		"end"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// Format is a printf format string to format the value in the
		// sequence
		"format"?: string

		// Number at which to start the sequence (default: 0)
		"start"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"
	}

	// StopStrategy defines if the CronWorkflow should stop scheduling
	// based on an expression. v3.6 and after
	#: "io.argoproj.workflow.v1alpha1.StopStrategy": {
		// v3.6 and after: Expression is an expression that stops
		// scheduling workflows when true. Use the variables
		// `cronworkflow`.`failed` or `cronworkflow`.`succeeded` to
		// access the number of failed or successful child workflows.
		"expression"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.Submit": {
		// Arguments extracted from the event and then set as arguments to
		// the workflow created.
		"arguments"?: #."io.argoproj.workflow.v1alpha1.Arguments"

		// Metadata optional means to customize select fields of the
		// workflow metadata
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"

		// WorkflowTemplateRef the workflow template to submit
		"workflowTemplateRef"!: #."io.argoproj.workflow.v1alpha1.WorkflowTemplateRef"
	}

	// SubmitOpts are workflow submission options
	#: "io.argoproj.workflow.v1alpha1.SubmitOpts": {
		// Annotations adds to metadata.labels
		"annotations"?: string

		// DryRun validates the workflow on the client-side without
		// creating it. This option is not supported in API
		"dryRun"?: bool

		// Entrypoint overrides spec.entrypoint
		"entryPoint"?: string

		// GenerateName overrides metadata.generateName
		"generateName"?: string

		// Labels adds to metadata.labels
		"labels"?: string

		// Name overrides metadata.name
		"name"?: string

		// OwnerReference creates a metadata.ownerReference
		"ownerReference"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"

		// Parameters passes input parameters to workflow
		"parameters"?: [...string]

		// Set the podPriorityClassName of the workflow
		"podPriorityClassName"?: string

		// Priority is used if controller is configured to process limited
		// number of workflows in parallel, higher priority workflows are
		// processed first.
		"priority"?: int

		// ServerDryRun validates the workflow on the server-side without
		// creating it
		"serverDryRun"?: bool

		// ServiceAccount runs all pods in the workflow using specified
		// ServiceAccount.
		"serviceAccount"?: string
	}

	// SuppliedValueFrom is a placeholder for a value to be filled in
	// directly, either through the CLI, API, etc.
	#: "io.argoproj.workflow.v1alpha1.SuppliedValueFrom": {}

	// SuspendTemplate is a template subtype to suspend a workflow at
	// a predetermined point in time
	#: "io.argoproj.workflow.v1alpha1.SuspendTemplate": {
		// Duration is the seconds to wait before automatically resuming a
		// template. Must be a string. Default unit is seconds. Could
		// also be a Duration, e.g.: "2m", "6h"
		"duration"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.SyncDatabaseRef": "key"!: string

	// Synchronization holds synchronization lock configuration
	#: "io.argoproj.workflow.v1alpha1.Synchronization": {
		// v3.6 and after: Mutexes holds the list of Mutex lock details
		"mutexes"?: [...#."io.argoproj.workflow.v1alpha1.Mutex"]

		// v3.6 and after: Semaphores holds the list of Semaphores
		// configuration
		"semaphores"?: [...#."io.argoproj.workflow.v1alpha1.SemaphoreRef"]
	}

	// SynchronizationStatus stores the status of semaphore and mutex.
	#: "io.argoproj.workflow.v1alpha1.SynchronizationStatus": {
		// Mutex stores this workflow's mutex holder details
		"mutex"?: #."io.argoproj.workflow.v1alpha1.MutexStatus"

		// Semaphore stores this workflow's Semaphore holder details
		"semaphore"?: #."io.argoproj.workflow.v1alpha1.SemaphoreStatus"
	}

	// TTLStrategy is the strategy for the time to live depending on
	// if the workflow succeeded or failed
	#: "io.argoproj.workflow.v1alpha1.TTLStrategy": {
		// SecondsAfterCompletion is the number of seconds to live after
		// completion
		"secondsAfterCompletion"?: int

		// SecondsAfterFailure is the number of seconds to live after
		// failure
		"secondsAfterFailure"?: int

		// SecondsAfterSuccess is the number of seconds to live after
		// success
		"secondsAfterSuccess"?: int
	}

	// TarStrategy will tar and gzip the file or directory when saving
	#: "io.argoproj.workflow.v1alpha1.TarStrategy": {
		// CompressionLevel specifies the gzip compression level to use
		// for the artifact. Defaults to gzip.DefaultCompression.
		"compressionLevel"?: int
	}

	// Template is a reusable and composable unit of execution in a
	// workflow
	#: "io.argoproj.workflow.v1alpha1.Template": {
		// Optional duration in seconds relative to the StartTime that the
		// pod may be active on a node before the system actively tries
		// to terminate the pod; value must be positive integer This
		// field is only applicable to container and script templates.
		"activeDeadlineSeconds"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// Affinity sets the pod's scheduling constraints Overrides the
		// affinity set at the workflow level (if any)
		"affinity"?: #."io.k8s.api.core.v1.Affinity"

		// Annotations is a list of annotations to add to the template at
		// runtime
		"annotations"?: {
			[string]: string
		}

		// Location in which all files related to the step will be stored
		// (logs, artifacts, etc...). Can be overridden by individual
		// items in Outputs. If omitted, will use the default artifact
		// repository location configured in the controller, appended
		// with the <workflowname>/<nodename> in the key.
		"archiveLocation"?: #."io.argoproj.workflow.v1alpha1.ArtifactLocation"

		// AutomountServiceAccountToken indicates whether a service
		// account token should be automatically mounted in pods.
		// ServiceAccountName of ExecutorConfig must be specified if this
		// value is false.
		"automountServiceAccountToken"?: bool

		// Container is the main container image to run in the pod
		"container"?: #."io.k8s.api.core.v1.Container"

		// ContainerSet groups multiple containers within a single pod.
		"containerSet"?: #."io.argoproj.workflow.v1alpha1.ContainerSetTemplate"

		// Daemon will allow a workflow to proceed to the next step so
		// long as the container reaches readiness
		"daemon"?: bool

		// DAG template subtype which runs a DAG
		"dag"?: #."io.argoproj.workflow.v1alpha1.DAGTemplate"

		// Data is a data template
		"data"?: #."io.argoproj.workflow.v1alpha1.Data"

		// Executor holds configurations of the executor container.
		"executor"?: #."io.argoproj.workflow.v1alpha1.ExecutorConfig"

		// FailFast, if specified, will fail this template if any of its
		// child pods has failed. This is useful for when this template
		// is expanded with `withItems`, etc.
		"failFast"?: bool

		// HostAliases is an optional list of hosts and IPs that will be
		// injected into the pod spec
		"hostAliases"?: [...#."io.k8s.api.core.v1.HostAlias"]

		// HTTP makes a HTTP request
		"http"?: #."io.argoproj.workflow.v1alpha1.HTTP"

		// InitContainers is a list of containers which run before the
		// main container.
		"initContainers"?: [...#."io.argoproj.workflow.v1alpha1.UserContainer"]

		// Inputs describe what inputs parameters and artifacts are
		// supplied to this template
		"inputs"?: #."io.argoproj.workflow.v1alpha1.Inputs"

		// Memoize allows templates to use outputs generated from already
		// executed templates
		"memoize"?: #."io.argoproj.workflow.v1alpha1.Memoize"

		// Metadata sets the pods's metadata, i.e. annotations and labels
		"metadata"?: #."io.argoproj.workflow.v1alpha1.Metadata"

		// Metrics are a list of metrics emitted from this template
		"metrics"?: #."io.argoproj.workflow.v1alpha1.Metrics"

		// Name is the name of the template
		"name"?: string

		// NodeSelector is a selector to schedule this step of the
		// workflow to be run on the selected node(s). Overrides the
		// selector set at the workflow level.
		"nodeSelector"?: {
			[string]: string
		}

		// Outputs describe the parameters and artifacts that this
		// template produces
		"outputs"?: #."io.argoproj.workflow.v1alpha1.Outputs"

		// Parallelism limits the max total parallel pods that can execute
		// at the same time within the boundaries of this template
		// invocation. If additional steps/dag templates are invoked, the
		// pods created by those templates will not be counted towards
		// this total.
		"parallelism"?: int

		// Plugin is a plugin template Note: the structure of a plugin
		// template is free-form, so we need to have
		// "x-kubernetes-preserve-unknown-fields: true" in the validation
		// schema.
		"plugin"?: #."io.argoproj.workflow.v1alpha1.Plugin"

		// PodSpecPatch holds strategic merge patch to apply against the
		// pod spec. Allows parameterization of container fields which
		// are not strings (e.g. resource limits).
		"podSpecPatch"?: string

		// PriorityClassName to apply to workflow pods.
		"priorityClassName"?: string

		// Resource template subtype which can run k8s resources
		"resource"?: #."io.argoproj.workflow.v1alpha1.ResourceTemplate"

		// RetryStrategy describes how to retry a template when it fails
		"retryStrategy"?: #."io.argoproj.workflow.v1alpha1.RetryStrategy"

		// If specified, the pod will be dispatched by specified
		// scheduler. Or it will be dispatched by workflow scope
		// scheduler if specified. If neither specified, the pod will be
		// dispatched by default scheduler.
		"schedulerName"?: string

		// Script runs a portion of code against an interpreter
		"script"?: #."io.argoproj.workflow.v1alpha1.ScriptTemplate"

		// SecurityContext holds pod-level security attributes and common
		// container settings. Optional: Defaults to empty. See type
		// description for default values of each field.
		"securityContext"?: #."io.k8s.api.core.v1.PodSecurityContext"

		// ServiceAccountName to apply to workflow pods
		"serviceAccountName"?: string

		// Sidecars is a list of containers which run alongside the main
		// container Sidecars are automatically killed when the main
		// container completes
		"sidecars"?: [...#."io.argoproj.workflow.v1alpha1.UserContainer"]

		// Steps define a series of sequential/parallel workflow steps
		"steps"?: [...#."io.argoproj.workflow.v1alpha1.ParallelSteps"]

		// Suspend template subtype which can suspend a workflow when
		// reaching the step
		"suspend"?: #."io.argoproj.workflow.v1alpha1.SuspendTemplate"

		// Synchronization holds synchronization lock configuration for
		// this template
		"synchronization"?: #."io.argoproj.workflow.v1alpha1.Synchronization"

		// Timeout allows to set the total node execution timeout duration
		// counting from the node's start time. This duration also
		// includes time in which the node spends in Pending state. This
		// duration may not be applied to Step or DAG templates.
		"timeout"?: string

		// Tolerations to apply to workflow pods.
		"tolerations"?: [...#."io.k8s.api.core.v1.Toleration"]

		// Volumes is a list of volumes that can be mounted by containers
		// in a template.
		"volumes"?: [...#."io.k8s.api.core.v1.Volume"]
	}

	// TemplateRef is a reference of template resource.
	#: "io.argoproj.workflow.v1alpha1.TemplateRef": {
		// ClusterScope indicates the referred template is cluster scoped
		// (i.e. a ClusterWorkflowTemplate).
		"clusterScope"?: bool

		// Name is the resource name of the template.
		"name"?: string

		// Template is the name of referred template in the resource.
		"template"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.TransformationStep": {
		// Expression defines an expr expression to apply
		"expression"!: string
	}

	#: "io.argoproj.workflow.v1alpha1.UpdateCronWorkflowRequest": {
		"cronWorkflow"?: #."io.argoproj.workflow.v1alpha1.CronWorkflow"

		// DEPRECATED: This field is ignored.
		"name"?:      string
		"namespace"?: string
	}

	// UserContainer is a container specified by a user.
	#: "io.argoproj.workflow.v1alpha1.UserContainer": {
		// Arguments to the entrypoint. The container image's CMD is used
		// if this is not provided. Variable references $(VAR_NAME) are
		// expanded using the container's environment. If a variable
		// cannot be resolved, the reference in the input string will be
		// unchanged. Double $$ are reduced to a single $, which allows
		// for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will
		// produce the string literal "$(VAR_NAME)". Escaped references
		// will never be expanded, regardless of whether the variable
		// exists or not. Cannot be updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"args"?: [...string]

		// Entrypoint array. Not executed within a shell. The container
		// image's ENTRYPOINT is used if this is not provided. Variable
		// references $(VAR_NAME) are expanded using the container's
		// environment. If a variable cannot be resolved, the reference
		// in the input string will be unchanged. Double $$ are reduced
		// to a single $, which allows for escaping the $(VAR_NAME)
		// syntax: i.e. "$$(VAR_NAME)" will produce the string literal
		// "$(VAR_NAME)". Escaped references will never be expanded,
		// regardless of whether the variable exists or not. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"command"?: [...string]

		// List of environment variables to set in the container. Cannot
		// be updated.
		"env"?: [...#."io.k8s.api.core.v1.EnvVar"]

		// List of sources to populate environment variables in the
		// container. The keys defined within a source must be a
		// C_IDENTIFIER. All invalid keys will be reported as an event
		// when the container is starting. When a key exists in multiple
		// sources, the value associated with the last source will take
		// precedence. Values defined by an Env with a duplicate key will
		// take precedence. Cannot be updated.
		"envFrom"?: [...#."io.k8s.api.core.v1.EnvFromSource"]

		// Container image name. More info:
		// https://kubernetes.io/docs/concepts/containers/images This
		// field is optional to allow higher level config management to
		// default or override container images in workload controllers
		// like Deployments and StatefulSets.
		"image"?: string

		// Image pull policy. One of Always, Never, IfNotPresent. Defaults
		// to Always if :latest tag is specified, or IfNotPresent
		// otherwise. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/containers/images#updating-images
		"imagePullPolicy"?: string

		// Actions that the management system should take in response to
		// container lifecycle events. Cannot be updated.
		"lifecycle"?: #."io.k8s.api.core.v1.Lifecycle"

		// Periodic probe of container liveness. Container will be
		// restarted if the probe fails. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"livenessProbe"?: #."io.k8s.api.core.v1.Probe"

		// MirrorVolumeMounts will mount the same volumes specified in the
		// main container to the container (including artifacts), at the
		// same mountPaths. This enables dind daemon to partially see the
		// same filesystem as the main container in order to use features
		// such as docker volume binding
		"mirrorVolumeMounts"?: bool

		// Name of the container specified as a DNS_LABEL. Each container
		// in a pod must have a unique name (DNS_LABEL). Cannot be
		// updated.
		"name"!: string

		// List of ports to expose from the container. Not specifying a
		// port here DOES NOT prevent that port from being exposed. Any
		// port which is listening on the default "0.0.0.0" address
		// inside a container will be accessible from the network.
		// Modifying this array with strategic merge patch may corrupt
		// the data. For more information See
		// https://github.com/kubernetes/kubernetes/issues/108255. Cannot
		// be updated.
		"ports"?: [...#."io.k8s.api.core.v1.ContainerPort"]

		// Periodic probe of container service readiness. Container will
		// be removed from service endpoints if the probe fails. Cannot
		// be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"readinessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Resources resize policy for the container.
		"resizePolicy"?: [...#."io.k8s.api.core.v1.ContainerResizePolicy"]

		// Compute Resources required by this container. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"resources"?: #."io.k8s.api.core.v1.ResourceRequirements"

		// RestartPolicy defines the restart behavior of individual
		// containers in a pod. This field may only be set for init
		// containers, and the only allowed value is "Always". For
		// non-init containers or when this field is not specified, the
		// restart behavior is defined by the Pod's restart policy and
		// the container type. Setting the RestartPolicy as "Always" for
		// the init container will have the following effect: this init
		// container will be continually restarted on exit until all
		// regular containers have terminated. Once all regular
		// containers have completed, all init containers with
		// restartPolicy "Always" will be shut down. This lifecycle
		// differs from normal init containers and is often referred to
		// as a "sidecar" container. Although this init container still
		// starts in the init container sequence, it does not wait for
		// the container to complete before proceeding to the next init
		// container. Instead, the next init container starts immediately
		// after this init container is started, or after any
		// startupProbe has successfully completed.
		"restartPolicy"?: string

		// SecurityContext defines the security options the container
		// should be run with. If set, the fields of SecurityContext
		// override the equivalent fields of PodSecurityContext. More
		// info:
		// https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
		"securityContext"?: #."io.k8s.api.core.v1.SecurityContext"

		// StartupProbe indicates that the Pod has successfully
		// initialized. If specified, no other probes are executed until
		// this completes successfully. If this probe fails, the Pod will
		// be restarted, just as if the livenessProbe failed. This can be
		// used to provide different probe parameters at the beginning of
		// a Pod's lifecycle, when it might take a long time to load data
		// or warm a cache, than during steady-state operation. This
		// cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"startupProbe"?: #."io.k8s.api.core.v1.Probe"

		// Whether this container should allocate a buffer for stdin in
		// the container runtime. If this is not set, reads from stdin in
		// the container will always result in EOF. Default is false.
		"stdin"?: bool

		// Whether the container runtime should close the stdin channel
		// after it has been opened by a single attach. When stdin is
		// true the stdin stream will remain open across multiple attach
		// sessions. If stdinOnce is set to true, stdin is opened on
		// container start, is empty until the first client attaches to
		// stdin, and then remains open and accepts data until the client
		// disconnects, at which time stdin is closed and remains closed
		// until the container is restarted. If this flag is false, a
		// container processes that reads from stdin will never receive
		// an EOF. Default is false
		"stdinOnce"?: bool

		// Optional: Path at which the file to which the container's
		// termination message will be written is mounted into the
		// container's filesystem. Message written is intended to be
		// brief final status, such as an assertion failure message. Will
		// be truncated by the node if greater than 4096 bytes. The total
		// message length across all containers will be limited to 12kb.
		// Defaults to /dev/termination-log. Cannot be updated.
		"terminationMessagePath"?: string

		// Indicate how the termination message should be populated. File
		// will use the contents of terminationMessagePath to populate
		// the container status message on both success and failure.
		// FallbackToLogsOnError will use the last chunk of container log
		// output if the termination message file is empty and the
		// container exited with an error. The log output is limited to
		// 2048 bytes or 80 lines, whichever is smaller. Defaults to
		// File. Cannot be updated.
		"terminationMessagePolicy"?: string

		// Whether this container should allocate a TTY for itself, also
		// requires 'stdin' to be true. Default is false.
		"tty"?: bool

		// volumeDevices is the list of block devices to be used by the
		// container.
		"volumeDevices"?: [...#."io.k8s.api.core.v1.VolumeDevice"]

		// Pod volumes to mount into the container's filesystem. Cannot be
		// updated.
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]

		// Container's working directory. If not specified, the container
		// runtime's default will be used, which might be configured in
		// the container image. Cannot be updated.
		"workingDir"?: string
	}

	// ValueFrom describes a location in which to obtain the value to
	// a parameter
	#: "io.argoproj.workflow.v1alpha1.ValueFrom": {
		// ConfigMapKeyRef is configmap selector for input parameter
		// configuration
		"configMapKeyRef"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// Default specifies a value to be used if retrieving the value
		// from the specified source fails
		"default"?: string

		// Selector (https://github.com/expr-lang/expr) that is evaluated
		// against the event to get the value of the parameter. E.g.
		// `payload.message`
		"event"?: string

		// Expression, if defined, is evaluated to specify the value for
		// the parameter
		"expression"?: string

		// JQFilter expression against the resource object in resource
		// templates
		"jqFilter"?: string

		// JSONPath of a resource to retrieve an output parameter value
		// from in resource templates
		"jsonPath"?: string

		// Parameter reference to a step or dag task in which to retrieve
		// an output parameter value from (e.g.
		// '{{steps.mystep.outputs.myparam}}')
		"parameter"?: string

		// Path in the container to retrieve an output parameter value
		// from in container templates
		"path"?: string

		// Supplied value to be filled in directly, either through the
		// CLI, API, etc.
		"supplied"?: #."io.argoproj.workflow.v1alpha1.SuppliedValueFrom"
	}

	#: "io.argoproj.workflow.v1alpha1.Version": {
		"buildDate"!:    string
		"compiler"!:     string
		"gitCommit"!:    string
		"gitTag"!:       string
		"gitTreeState"!: string
		"goVersion"!:    string
		"platform"!:     string
		"version"!:      string
	}

	// VolumeClaimGC describes how to delete volumes from completed
	// Workflows
	#: "io.argoproj.workflow.v1alpha1.VolumeClaimGC": {
		// Strategy is the strategy to use. One of "OnWorkflowCompletion",
		// "OnWorkflowSuccess". Defaults to "OnWorkflowSuccess"
		"strategy"?: string
	}

	// Workflow is the definition of a workflow resource
	#: "io.argoproj.workflow.v1alpha1.Workflow": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: "argoproj.io/v1alpha1"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     "Workflow"
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"!:     #."io.argoproj.workflow.v1alpha1.WorkflowSpec"
		"status"?:   #."io.argoproj.workflow.v1alpha1.WorkflowStatus"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowCreateRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"

		// This field is no longer used.
		"instanceID"?:   string
		"namespace"?:    string
		"serverDryRun"?: bool
		"workflow"?:     #."io.argoproj.workflow.v1alpha1.Workflow"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowDeleteResponse": {}

	// WorkflowEventBinding is the definition of an event resource
	#: "io.argoproj.workflow.v1alpha1.WorkflowEventBinding": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: "argoproj.io/v1alpha1"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     "WorkflowEventBinding"
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"!:     #."io.argoproj.workflow.v1alpha1.WorkflowEventBindingSpec"
	}

	// WorkflowEventBindingList is list of event resources
	#: "io.argoproj.workflow.v1alpha1.WorkflowEventBindingList": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string
		"items"!: [...#."io.argoproj.workflow.v1alpha1.WorkflowEventBinding"]

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     string
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowEventBindingSpec": {
		// Event is the event to bind to
		"event"!: #."io.argoproj.workflow.v1alpha1.Event"

		// Submit is the workflow template to submit
		"submit"?: #."io.argoproj.workflow.v1alpha1.Submit"
	}

	// WorkflowLevelArtifactGC describes how to delete artifacts from
	// completed Workflows - this spec is used on the Workflow level
	#: "io.argoproj.workflow.v1alpha1.WorkflowLevelArtifactGC": {
		// ForceFinalizerRemoval: if set to true, the finalizer will be
		// removed in the case that Artifact GC fails
		"forceFinalizerRemoval"?: bool

		// PodMetadata is an optional field for specifying the Labels and
		// Annotations that should be assigned to the Pod doing the
		// deletion
		"podMetadata"?: #."io.argoproj.workflow.v1alpha1.Metadata"

		// PodSpecPatch holds strategic merge patch to apply against the
		// artgc pod spec.
		"podSpecPatch"?: string

		// ServiceAccountName is an optional field for specifying the
		// Service Account that should be assigned to the Pod doing the
		// deletion
		"serviceAccountName"?: string

		// Strategy is the strategy to use.
		"strategy"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowLintRequest": {
		"namespace"?: string
		"workflow"?:  #."io.argoproj.workflow.v1alpha1.Workflow"
	}

	// WorkflowList is list of Workflow resources
	#: "io.argoproj.workflow.v1alpha1.WorkflowList": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string
		"items"!: [...#."io.argoproj.workflow.v1alpha1.Workflow"]

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     string
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowMetadata": {
		"annotations"?: [string]: string
		"labels"?: {
			[string]: string
		}
		"labelsFrom"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.LabelValueFrom"
		}
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowResubmitRequest": {
		"memoized"?:  bool
		"name"?:      string
		"namespace"?: string
		"parameters"?: [...string]
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowResumeRequest": {
		"name"?:              string
		"namespace"?:         string
		"nodeFieldSelector"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowRetryRequest": {
		"name"?:              string
		"namespace"?:         string
		"nodeFieldSelector"?: string
		"parameters"?: [...string]
		"restartSuccessful"?: bool
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowSetRequest": {
		"message"?:           string
		"name"?:              string
		"namespace"?:         string
		"nodeFieldSelector"?: string
		"outputParameters"?:  string
		"phase"?:             string
	}

	// WorkflowSpec is the specification of a Workflow.
	#: "io.argoproj.workflow.v1alpha1.WorkflowSpec": {
		// Optional duration in seconds relative to the workflow start
		// time which the workflow is allowed to run before the
		// controller terminates the io.argoproj.workflow.v1alpha1. A
		// value of zero is used to terminate a Running workflow
		"activeDeadlineSeconds"?: int

		// Affinity sets the scheduling constraints for all pods in the
		// io.argoproj.workflow.v1alpha1. Can be overridden by an
		// affinity specified in the template
		"affinity"?: #."io.k8s.api.core.v1.Affinity"

		// ArchiveLogs indicates if the container logs should be archived
		"archiveLogs"?: bool

		// Arguments contain the parameters and artifacts sent to the
		// workflow entrypoint Parameters are referencable globally using
		// the 'workflow' variable prefix. e.g.
		// {{io.argoproj.workflow.v1alpha1.parameters.myparam}}
		"arguments"?: #."io.argoproj.workflow.v1alpha1.Arguments"

		// ArtifactGC describes the strategy to use when deleting
		// artifacts from completed or deleted workflows (applies to all
		// output Artifacts unless Artifact.ArtifactGC is specified,
		// which overrides this)
		"artifactGC"?: #."io.argoproj.workflow.v1alpha1.WorkflowLevelArtifactGC"

		// ArtifactRepositoryRef specifies the configMap name and key
		// containing the artifact repository config.
		"artifactRepositoryRef"?: #."io.argoproj.workflow.v1alpha1.ArtifactRepositoryRef"

		// AutomountServiceAccountToken indicates whether a service
		// account token should be automatically mounted in pods.
		// ServiceAccountName of ExecutorConfig must be specified if this
		// value is false.
		"automountServiceAccountToken"?: bool

		// PodDNSConfig defines the DNS parameters of a pod in addition to
		// those generated from DNSPolicy.
		"dnsConfig"?: #."io.k8s.api.core.v1.PodDNSConfig"

		// Set DNS policy for workflow pods. Defaults to "ClusterFirst".
		// Valid values are 'ClusterFirstWithHostNet', 'ClusterFirst',
		// 'Default' or 'None'. DNS parameters given in DNSConfig will be
		// merged with the policy selected with DNSPolicy. To have DNS
		// options set along with hostNetwork, you have to specify DNS
		// policy explicitly to 'ClusterFirstWithHostNet'.
		"dnsPolicy"?: string

		// Entrypoint is a template reference to the starting point of the
		// io.argoproj.workflow.v1alpha1.
		"entrypoint"?: string

		// Executor holds configurations of executor containers of the
		// io.argoproj.workflow.v1alpha1.
		"executor"?: #."io.argoproj.workflow.v1alpha1.ExecutorConfig"

		// Hooks holds the lifecycle hook which is invoked at lifecycle of
		// step, irrespective of the success, failure, or error status of
		// the primary step
		"hooks"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.LifecycleHook"
		}
		"hostAliases"?: [...#."io.k8s.api.core.v1.HostAlias"]

		// Host networking requested for this workflow pod. Default to
		// false.
		"hostNetwork"?: bool

		// ImagePullSecrets is a list of references to secrets in the same
		// namespace to use for pulling any images in pods that reference
		// this ServiceAccount. ImagePullSecrets are distinct from
		// Secrets because Secrets can be mounted in the pod, but
		// ImagePullSecrets are only accessed by the kubelet. More info:
		// https://kubernetes.io/docs/concepts/containers/images/#specifying-imagepullsecrets-on-a-pod
		"imagePullSecrets"?: [...#."io.k8s.api.core.v1.LocalObjectReference"]

		// Metrics are a list of metrics emitted from this Workflow
		"metrics"?: #."io.argoproj.workflow.v1alpha1.Metrics"

		// NodeSelector is a selector which will result in all pods of the
		// workflow to be scheduled on the selected node(s). This is able
		// to be overridden by a nodeSelector specified in the template.
		"nodeSelector"?: {
			[string]: string
		}

		// OnExit is a template reference which is invoked at the end of
		// the workflow, irrespective of the success, failure, or error
		// of the primary io.argoproj.workflow.v1alpha1.
		"onExit"?: string

		// Parallelism limits the max total parallel pods that can execute
		// at the same time in a workflow
		"parallelism"?: int

		// PodDisruptionBudget holds the number of concurrent disruptions
		// that you allow for Workflow's Pods. Controller will
		// automatically add the selector with workflow name, if selector
		// is empty. Optional: Defaults to empty.
		"podDisruptionBudget"?: #."io.k8s.api.policy.v1.PodDisruptionBudgetSpec"

		// PodGC describes the strategy to use when deleting completed
		// pods
		"podGC"?: #."io.argoproj.workflow.v1alpha1.PodGC"

		// PodMetadata defines additional metadata that should be applied
		// to workflow pods
		"podMetadata"?: #."io.argoproj.workflow.v1alpha1.Metadata"

		// PriorityClassName to apply to workflow pods.
		"podPriorityClassName"?: string

		// PodSpecPatch holds strategic merge patch to apply against the
		// pod spec. Allows parameterization of container fields which
		// are not strings (e.g. resource limits).
		"podSpecPatch"?: string

		// Priority is used if controller is configured to process limited
		// number of workflows in parallel. Workflows with higher
		// priority are processed first.
		"priority"?: int

		// RetryStrategy for all templates in the
		// io.argoproj.workflow.v1alpha1.
		"retryStrategy"?: #."io.argoproj.workflow.v1alpha1.RetryStrategy"

		// Set scheduler name for all pods. Will be overridden if
		// container/script template's scheduler name is set. Default
		// scheduler will be used if neither specified.
		"schedulerName"?: string

		// SecurityContext holds pod-level security attributes and common
		// container settings. Optional: Defaults to empty. See type
		// description for default values of each field.
		"securityContext"?: #."io.k8s.api.core.v1.PodSecurityContext"

		// ServiceAccountName is the name of the ServiceAccount to run all
		// pods of the workflow as.
		"serviceAccountName"?: string

		// Shutdown will shutdown the workflow according to its
		// ShutdownStrategy
		"shutdown"?: string

		// Suspend will suspend the workflow and prevent execution of any
		// future steps in the workflow
		"suspend"?: bool

		// Synchronization holds synchronization lock configuration for
		// this Workflow
		"synchronization"?: #."io.argoproj.workflow.v1alpha1.Synchronization"

		// TemplateDefaults holds default template values that will apply
		// to all templates in the Workflow, unless overridden on the
		// template-level
		"templateDefaults"?: #."io.argoproj.workflow.v1alpha1.Template"

		// Templates is a list of workflow templates used in a workflow
		// MaxItems is an artificial limit to limit CEL validation costs
		// - see note at top of file
		"templates"?: [...#."io.argoproj.workflow.v1alpha1.Template"]

		// Tolerations to apply to workflow pods.
		"tolerations"?: [...#."io.k8s.api.core.v1.Toleration"]

		// TTLStrategy limits the lifetime of a Workflow that has finished
		// execution depending on if it Succeeded or Failed. If this
		// struct is set, once the Workflow finishes, it will be deleted
		// after the time to live expires. If this field is unset, the
		// controller config map will hold the default values.
		"ttlStrategy"?: #."io.argoproj.workflow.v1alpha1.TTLStrategy"

		// VolumeClaimGC describes the strategy to use when deleting
		// volumes from completed workflows
		"volumeClaimGC"?: #."io.argoproj.workflow.v1alpha1.VolumeClaimGC"

		// VolumeClaimTemplates is a list of claims that containers are
		// allowed to reference. The Workflow controller will create the
		// claims at the beginning of the workflow and delete the claims
		// upon completion of the workflow
		"volumeClaimTemplates"?: [...#."io.k8s.api.core.v1.PersistentVolumeClaim"]

		// Volumes is a list of volumes that can be mounted by containers
		// in a io.argoproj.workflow.v1alpha1.
		"volumes"?: [...#."io.k8s.api.core.v1.Volume"]

		// WorkflowMetadata contains some metadata of the workflow to
		// refer to
		"workflowMetadata"?: #."io.argoproj.workflow.v1alpha1.WorkflowMetadata"

		// WorkflowTemplateRef holds a reference to a WorkflowTemplate for
		// execution
		"workflowTemplateRef"?: #."io.argoproj.workflow.v1alpha1.WorkflowTemplateRef"
	}

	// WorkflowStatus contains overall status information about a
	// workflow
	#: "io.argoproj.workflow.v1alpha1.WorkflowStatus": {
		// ArtifactGCStatus maintains the status of Artifact Garbage
		// Collection
		"artifactGCStatus"?: #."io.argoproj.workflow.v1alpha1.ArtGCStatus"

		// ArtifactRepositoryRef is used to cache the repository to use so
		// we do not need to determine it everytime we reconcile.
		"artifactRepositoryRef"?: #."io.argoproj.workflow.v1alpha1.ArtifactRepositoryRefStatus"

		// Compressed and base64 decoded Nodes map
		"compressedNodes"?: string

		// Conditions is a list of conditions the Workflow may have
		"conditions"?: [...#."io.argoproj.workflow.v1alpha1.Condition"]

		// EstimatedDuration in seconds.
		"estimatedDuration"?: int

		// Time at which this workflow completed
		"finishedAt"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// A human readable message indicating details about why the
		// workflow is in this condition.
		"message"?: string

		// Nodes is a mapping between a node ID and the node's status.
		"nodes"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.NodeStatus"
		}

		// Whether on not node status has been offloaded to a database. If
		// exists, then Nodes and CompressedNodes will be empty. This
		// will actually be populated with a hash of the offloaded data.
		"offloadNodeStatusVersion"?: string

		// Outputs captures output values and artifact locations produced
		// by the workflow via global outputs
		"outputs"?: #."io.argoproj.workflow.v1alpha1.Outputs"

		// PersistentVolumeClaims tracks all PVCs that were created as
		// part of the io.argoproj.workflow.v1alpha1. The contents of
		// this list are drained at the end of the workflow.
		"persistentVolumeClaims"?: [...#."io.k8s.api.core.v1.Volume"]

		// Phase a simple, high-level summary of where the workflow is in
		// its lifecycle. Will be "" (Unknown), "Pending", or "Running"
		// before the workflow is completed, and "Succeeded", "Failed" or
		// "Error" once the workflow has completed.
		"phase"?: string

		// Progress to completion
		"progress"?: string

		// ResourcesDuration is the total for the workflow
		"resourcesDuration"?: {
			[string]: int
		}

		// Time at which this workflow started
		"startedAt"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// StoredTemplates is a mapping between a template ref and the
		// node's status.
		"storedTemplates"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.Template"
		}

		// StoredWorkflowSpec stores the WorkflowTemplate spec for future
		// execution.
		"storedWorkflowTemplateSpec"?: #."io.argoproj.workflow.v1alpha1.WorkflowSpec"

		// Synchronization stores the status of synchronization locks
		"synchronization"?: #."io.argoproj.workflow.v1alpha1.SynchronizationStatus"

		// TaskResultsCompletionStatus tracks task result completion
		// status (mapped by node ID). Used to prevent premature
		// archiving and garbage collection.
		"taskResultsCompletionStatus"?: {
			[string]: bool
		}
	}

	// WorkflowStep is a reference to a template to execute in a
	// series of step Note: CEL validation cannot check withItems
	// (Schemaless) or inline (PreserveUnknownFields) fields.
	#: "io.argoproj.workflow.v1alpha1.WorkflowStep": {
		// Arguments hold arguments to the template
		"arguments"?: #."io.argoproj.workflow.v1alpha1.Arguments"

		// ContinueOn makes argo to proceed with the following step even
		// if this step fails. Errors and Failed states can be specified
		"continueOn"?: #."io.argoproj.workflow.v1alpha1.ContinueOn"

		// Hooks holds the lifecycle hook which is invoked at lifecycle of
		// step, irrespective of the success, failure, or error status of
		// the primary step
		"hooks"?: {
			[string]: #."io.argoproj.workflow.v1alpha1.LifecycleHook"
		}

		// Inline is the template. Template must be empty if this is
		// declared (and vice-versa). Note: This struct is defined
		// recursively, since the inline template can potentially contain
		// steps/DAGs that also has an "inline" field. Kubernetes doesn't
		// allow recursive types, so we need
		// "x-kubernetes-preserve-unknown-fields: true" in the validation
		// schema.
		"inline"?: #."io.argoproj.workflow.v1alpha1.Template"

		// Name of the step
		"name"?: string

		// OnExit is a template reference which is invoked at the end of
		// the template, irrespective of the success, failure, or error
		// of the primary template. DEPRECATED: Use Hooks[exit].Template
		// instead.
		"onExit"?: string

		// Template is the name of the template to execute as the step
		"template"?: string

		// TemplateRef is the reference to the template resource to
		// execute as the step.
		"templateRef"?: #."io.argoproj.workflow.v1alpha1.TemplateRef"

		// When is an expression in which the step should conditionally
		// execute
		"when"?: string

		// WithItems expands a step into multiple parallel steps from the
		// items in the list Note: The structure of WithItems is
		// free-form, so we need "x-kubernetes-preserve-unknown-fields:
		// true" in the validation schema.
		"withItems"?: [...#."io.argoproj.workflow.v1alpha1.Item"]

		// WithParam expands a step into multiple parallel steps from the
		// value in the parameter, which is expected to be a JSON list.
		"withParam"?: string

		// WithSequence expands a step into a numeric sequence
		"withSequence"?: #."io.argoproj.workflow.v1alpha1.Sequence"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowStopRequest": {
		"message"?:           string
		"name"?:              string
		"namespace"?:         string
		"nodeFieldSelector"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowSubmitRequest": {
		"namespace"?:     string
		"resourceKind"?:  string
		"resourceName"?:  string
		"submitOptions"?: #."io.argoproj.workflow.v1alpha1.SubmitOpts"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowSuspendRequest": {
		"name"?:      string
		"namespace"?: string
	}

	// WorkflowTemplate is the definition of a workflow template
	// resource
	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplate": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: "argoproj.io/v1alpha1"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     "WorkflowTemplate"
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"
		"spec"!:     #."io.argoproj.workflow.v1alpha1.WorkflowSpec"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateCreateRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"namespace"?:     string
		"template"?:      #."io.argoproj.workflow.v1alpha1.WorkflowTemplate"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateDeleteResponse": {}

	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateLintRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"namespace"?:     string
		"template"?:      #."io.argoproj.workflow.v1alpha1.WorkflowTemplate"
	}

	// WorkflowTemplateList is list of WorkflowTemplate resources
	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateList": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string
		"items"!: [...#."io.argoproj.workflow.v1alpha1.WorkflowTemplate"]

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.io.k8s.community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?:     string
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta"
	}

	// WorkflowTemplateRef is a reference to a WorkflowTemplate
	// resource.
	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateRef": {
		// ClusterScope indicates the referred template is cluster scoped
		// (i.e. a ClusterWorkflowTemplate).
		"clusterScope"?: bool

		// Name is the resource name of the workflow template.
		"name"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowTemplateUpdateRequest": {
		// DEPRECATED: This field is ignored.
		"name"?:      string
		"namespace"?: string
		"template"?:  #."io.argoproj.workflow.v1alpha1.WorkflowTemplate"
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowTerminateRequest": {
		"name"?:      string
		"namespace"?: string
	}

	#: "io.argoproj.workflow.v1alpha1.WorkflowWatchEvent": {
		// the workflow
		"object"?: #."io.argoproj.workflow.v1alpha1.Workflow"

		// the type of change
		"type"?: string
	}

	// ZipStrategy will unzip zipped input artifacts
	#: "io.argoproj.workflow.v1alpha1.ZipStrategy": {}

	// Represents a Persistent Disk resource in AWS.
	//
	// An AWS EBS disk must exist before mounting to a container. The
	// disk must also be in the same AWS zone as the kubelet. An AWS
	// EBS disk can only be mounted as read/write once. AWS EBS
	// volumes support ownership management and SELinux relabeling.
	#: "io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource": {
		// fsType is the filesystem type of the volume that you want to
		// mount. Tip: Ensure that the filesystem type is supported by
		// the host operating system. Examples: "ext4", "xfs", "ntfs".
		// Implicitly inferred to be "ext4" if unspecified. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
		"fsType"?: string

		// partition is the partition in the volume that you want to
		// mount. If omitted, the default is to mount by volume name.
		// Examples: For volume /dev/sda1, you specify the partition as
		// "1". Similarly, the volume partition for /dev/sda is "0" (or
		// you can leave the property empty).
		"partition"?: int

		// readOnly value true will force the readOnly setting in
		// VolumeMounts. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
		"readOnly"?: bool

		// volumeID is unique ID of the persistent disk resource in AWS
		// (Amazon EBS volume). More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
		"volumeID"!: string
	}

	// Affinity is a group of affinity scheduling rules.
	#: "io.k8s.api.core.v1.Affinity": {
		// Describes node affinity scheduling rules for the pod.
		"nodeAffinity"?: #."io.k8s.api.core.v1.NodeAffinity"

		// Describes pod affinity scheduling rules (e.g. co-locate this
		// pod in the same node, zone, etc. as some other pod(s)).
		"podAffinity"?: #."io.k8s.api.core.v1.PodAffinity"

		// Describes pod anti-affinity scheduling rules (e.g. avoid
		// putting this pod in the same node, zone, etc. as some other
		// pod(s)).
		"podAntiAffinity"?: #."io.k8s.api.core.v1.PodAntiAffinity"
	}

	// AppArmorProfile defines a pod or container's AppArmor settings.
	#: "io.k8s.api.core.v1.AppArmorProfile": {
		// localhostProfile indicates a profile loaded on the node that
		// should be used. The profile must be preconfigured on the node
		// to work. Must match the loaded name of the profile. Must be
		// set if and only if type is "Localhost".
		"localhostProfile"?: string

		// type indicates which kind of AppArmor profile will be applied.
		// Valid options are:
		// Localhost - a profile pre-loaded on the node.
		// RuntimeDefault - the container runtime's default profile.
		// Unconfined - no AppArmor enforcement.
		"type"!: string
	}

	// AzureDisk represents an Azure Data Disk mount on the host and
	// bind mount to the pod.
	#: "io.k8s.api.core.v1.AzureDiskVolumeSource": {
		// cachingMode is the Host Caching mode: None, Read Only, Read
		// Write.
		"cachingMode"?: string

		// diskName is the Name of the data disk in the blob storage
		"diskName"!: string

		// diskURI is the URI of data disk in the blob storage
		"diskURI"!: string

		// fsType is Filesystem type to mount. Must be a filesystem type
		// supported by the host operating system. Ex. "ext4", "xfs",
		// "ntfs". Implicitly inferred to be "ext4" if unspecified.
		"fsType"?: string

		// kind expected values are Shared: multiple blob disks per
		// storage account Dedicated: single blob disk per storage
		// account Managed: azure managed data disk (only in managed
		// availability set). defaults to shared
		"kind"?: string

		// readOnly Defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool
	}

	// AzureFile represents an Azure File Service mount on the host
	// and bind mount to the pod.
	#: "io.k8s.api.core.v1.AzureFileVolumeSource": {
		// readOnly defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// secretName is the name of secret that contains Azure Storage
		// Account Name and Key
		"secretName"!: string

		// shareName is the azure share Name
		"shareName"!: string
	}

	// Represents a source location of a volume to mount, managed by
	// an external CSI driver
	#: "io.k8s.api.core.v1.CSIVolumeSource": {
		// driver is the name of the CSI driver that handles this volume.
		// Consult with your admin for the correct name as registered in
		// the cluster.
		"driver"!: string

		// fsType to mount. Ex. "ext4", "xfs", "ntfs". If not provided,
		// the empty value is passed to the associated CSI driver which
		// will determine the default filesystem to apply.
		"fsType"?: string

		// nodePublishSecretRef is a reference to the secret object
		// containing sensitive information to pass to the CSI driver to
		// complete the CSI NodePublishVolume and NodeUnpublishVolume
		// calls. This field is optional, and may be empty if no secret
		// is required. If the secret object contains more than one
		// secret, all secret references are passed.
		"nodePublishSecretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// readOnly specifies a read-only configuration for the volume.
		// Defaults to false (read/write).
		"readOnly"?: bool

		// volumeAttributes stores driver-specific properties that are
		// passed to the CSI driver. Consult your driver's documentation
		// for supported values.
		"volumeAttributes"?: {
			[string]: string
		}
	}

	// Adds and removes POSIX capabilities from running containers.
	#: "io.k8s.api.core.v1.Capabilities": {
		// Added capabilities
		"add"?: [...string]

		// Removed capabilities
		"drop"?: [...string]
	}

	// Represents a Ceph Filesystem mount that lasts the lifetime of a
	// pod Cephfs volumes do not support ownership management or
	// SELinux relabeling.
	#: "io.k8s.api.core.v1.CephFSVolumeSource": {
		// monitors is Required: Monitors is a collection of Ceph monitors
		// More info:
		// https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it
		"monitors"!: [...string]

		// path is Optional: Used as the mounted root, rather than the
		// full Ceph tree, default is /
		"path"?: string

		// readOnly is Optional: Defaults to false (read/write). ReadOnly
		// here will force the ReadOnly setting in VolumeMounts. More
		// info:
		// https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it
		"readOnly"?: bool

		// secretFile is Optional: SecretFile is the path to key ring for
		// User, default is /etc/ceph/user.secret More info:
		// https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it
		"secretFile"?: string

		// secretRef is Optional: SecretRef is reference to the
		// authentication secret for User, default is empty. More info:
		// https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// user is optional: User is the rados user name, default is admin
		// More info:
		// https://examples.k8s.io/volumes/cephfs/README.md#how-to-use-it
		"user"?: string
	}

	// Represents a cinder volume resource in Openstack. A Cinder
	// volume must exist before mounting to a container. The volume
	// must also be in the same region as the kubelet. Cinder volumes
	// support ownership management and SELinux relabeling.
	#: "io.k8s.api.core.v1.CinderVolumeSource": {
		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Examples: "ext4",
		// "xfs", "ntfs". Implicitly inferred to be "ext4" if
		// unspecified. More info:
		// https://examples.k8s.io/mysql-cinder-pd/README.md
		"fsType"?: string

		// readOnly defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts. More info:
		// https://examples.k8s.io/mysql-cinder-pd/README.md
		"readOnly"?: bool

		// secretRef is optional: points to a secret object containing
		// parameters used to connect to OpenStack.
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// volumeID used to identify the volume in cinder. More info:
		// https://examples.k8s.io/mysql-cinder-pd/README.md
		"volumeID"!: string
	}

	// ClusterTrustBundleProjection describes how to select a set of
	// ClusterTrustBundle objects and project their contents into the
	// pod filesystem.
	#: "io.k8s.api.core.v1.ClusterTrustBundleProjection": {
		// Select all ClusterTrustBundles that match this label selector.
		// Only has effect if signerName is set. Mutually-exclusive with
		// name. If unset, interpreted as "match nothing". If set but
		// empty, interpreted as "match everything".
		"labelSelector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// Select a single ClusterTrustBundle by object name.
		// Mutually-exclusive with signerName and labelSelector.
		"name"?: string

		// If true, don't block pod startup if the referenced
		// ClusterTrustBundle(s) aren't available. If using name, then
		// the named ClusterTrustBundle is allowed not to exist. If using
		// signerName, then the combination of signerName and
		// labelSelector is allowed to match zero ClusterTrustBundles.
		"optional"?: bool

		// Relative path from the volume root to write the bundle.
		"path"!: string

		// Select all ClusterTrustBundles that match this signer name.
		// Mutually-exclusive with name. The contents of all selected
		// ClusterTrustBundles will be unified and deduplicated.
		"signerName"?: string
	}

	// ConfigMapEnvSource selects a ConfigMap to populate the
	// environment variables with.
	//
	// The contents of the target ConfigMap's Data field will
	// represent the key-value pairs as environment variables.
	#: "io.k8s.api.core.v1.ConfigMapEnvSource": {
		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// Specify whether the ConfigMap must be defined
		"optional"?: bool
	}

	// Selects a key from a ConfigMap.
	#: "io.k8s.api.core.v1.ConfigMapKeySelector": {
		// The key to select.
		"key"!: string

		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// Specify whether the ConfigMap or its key must be defined
		"optional"?: bool
	}

	// Adapts a ConfigMap into a projected volume.
	//
	// The contents of the target ConfigMap's Data field will be
	// presented in a projected volume as files using the keys in the
	// Data field as the file names, unless the items element is
	// populated with specific mappings of keys to paths. Note that
	// this is identical to a configmap volume source without the
	// default mode.
	#: "io.k8s.api.core.v1.ConfigMapProjection": {
		// items if unspecified, each key-value pair in the Data field of
		// the referenced ConfigMap will be projected into the volume as
		// a file whose name is the key and content is the value. If
		// specified, the listed keys will be projected into the
		// specified paths, and unlisted keys will not be present. If a
		// key is specified which is not present in the ConfigMap, the
		// volume setup will error unless it is marked optional. Paths
		// must be relative and may not contain the '..' path or start
		// with '..'.
		"items"?: [...#."io.k8s.api.core.v1.KeyToPath"]

		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// optional specify whether the ConfigMap or its keys must be
		// defined
		"optional"?: bool
	}

	// Adapts a ConfigMap into a volume.
	//
	// The contents of the target ConfigMap's Data field will be
	// presented in a volume as files using the keys in the Data
	// field as the file names, unless the items element is populated
	// with specific mappings of keys to paths. ConfigMap volumes
	// support ownership management and SELinux relabeling.
	#: "io.k8s.api.core.v1.ConfigMapVolumeSource": {
		// defaultMode is optional: mode bits used to set permissions on
		// created files by default. Must be an octal value between 0000
		// and 0777 or a decimal value between 0 and 511. YAML accepts
		// both octal and decimal values, JSON requires decimal values
		// for mode bits. Defaults to 0644. Directories within the path
		// are not affected by this setting. This might be in conflict
		// with other options that affect the file mode, like fsGroup,
		// and the result can be other mode bits set.
		"defaultMode"?: int

		// items if unspecified, each key-value pair in the Data field of
		// the referenced ConfigMap will be projected into the volume as
		// a file whose name is the key and content is the value. If
		// specified, the listed keys will be projected into the
		// specified paths, and unlisted keys will not be present. If a
		// key is specified which is not present in the ConfigMap, the
		// volume setup will error unless it is marked optional. Paths
		// must be relative and may not contain the '..' path or start
		// with '..'.
		"items"?: [...#."io.k8s.api.core.v1.KeyToPath"]

		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// optional specify whether the ConfigMap or its keys must be
		// defined
		"optional"?: bool
	}

	// A single application container that you want to run within a
	// pod.
	#: "io.k8s.api.core.v1.Container": {
		// Arguments to the entrypoint. The container image's CMD is used
		// if this is not provided. Variable references $(VAR_NAME) are
		// expanded using the container's environment. If a variable
		// cannot be resolved, the reference in the input string will be
		// unchanged. Double $$ are reduced to a single $, which allows
		// for escaping the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will
		// produce the string literal "$(VAR_NAME)". Escaped references
		// will never be expanded, regardless of whether the variable
		// exists or not. Cannot be updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"args"?: [...string]

		// Entrypoint array. Not executed within a shell. The container
		// image's ENTRYPOINT is used if this is not provided. Variable
		// references $(VAR_NAME) are expanded using the container's
		// environment. If a variable cannot be resolved, the reference
		// in the input string will be unchanged. Double $$ are reduced
		// to a single $, which allows for escaping the $(VAR_NAME)
		// syntax: i.e. "$$(VAR_NAME)" will produce the string literal
		// "$(VAR_NAME)". Escaped references will never be expanded,
		// regardless of whether the variable exists or not. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/tasks/inject-data-application/define-command-argument-container/#running-a-command-in-a-shell
		"command"?: [...string]

		// List of environment variables to set in the container. Cannot
		// be updated.
		"env"?: [...#."io.k8s.api.core.v1.EnvVar"]

		// List of sources to populate environment variables in the
		// container. The keys defined within a source must be a
		// C_IDENTIFIER. All invalid keys will be reported as an event
		// when the container is starting. When a key exists in multiple
		// sources, the value associated with the last source will take
		// precedence. Values defined by an Env with a duplicate key will
		// take precedence. Cannot be updated.
		"envFrom"?: [...#."io.k8s.api.core.v1.EnvFromSource"]

		// Container image name. More info:
		// https://kubernetes.io/docs/concepts/containers/images This
		// field is optional to allow higher level config management to
		// default or override container images in workload controllers
		// like Deployments and StatefulSets.
		"image"!: string

		// Image pull policy. One of Always, Never, IfNotPresent. Defaults
		// to Always if :latest tag is specified, or IfNotPresent
		// otherwise. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/containers/images#updating-images
		"imagePullPolicy"?: string

		// Actions that the management system should take in response to
		// container lifecycle events. Cannot be updated.
		"lifecycle"?: #."io.k8s.api.core.v1.Lifecycle"

		// Periodic probe of container liveness. Container will be
		// restarted if the probe fails. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"livenessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Name of the container specified as a DNS_LABEL. Each container
		// in a pod must have a unique name (DNS_LABEL). Cannot be
		// updated.
		"name"?: string

		// List of ports to expose from the container. Not specifying a
		// port here DOES NOT prevent that port from being exposed. Any
		// port which is listening on the default "0.0.0.0" address
		// inside a container will be accessible from the network.
		// Modifying this array with strategic merge patch may corrupt
		// the data. For more information See
		// https://github.com/kubernetes/kubernetes/issues/108255. Cannot
		// be updated.
		"ports"?: [...#."io.k8s.api.core.v1.ContainerPort"]

		// Periodic probe of container service readiness. Container will
		// be removed from service endpoints if the probe fails. Cannot
		// be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"readinessProbe"?: #."io.k8s.api.core.v1.Probe"

		// Resources resize policy for the container.
		"resizePolicy"?: [...#."io.k8s.api.core.v1.ContainerResizePolicy"]

		// Compute Resources required by this container. Cannot be
		// updated. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"resources"?: #."io.k8s.api.core.v1.ResourceRequirements"

		// RestartPolicy defines the restart behavior of individual
		// containers in a pod. This field may only be set for init
		// containers, and the only allowed value is "Always". For
		// non-init containers or when this field is not specified, the
		// restart behavior is defined by the Pod's restart policy and
		// the container type. Setting the RestartPolicy as "Always" for
		// the init container will have the following effect: this init
		// container will be continually restarted on exit until all
		// regular containers have terminated. Once all regular
		// containers have completed, all init containers with
		// restartPolicy "Always" will be shut down. This lifecycle
		// differs from normal init containers and is often referred to
		// as a "sidecar" container. Although this init container still
		// starts in the init container sequence, it does not wait for
		// the container to complete before proceeding to the next init
		// container. Instead, the next init container starts immediately
		// after this init container is started, or after any
		// startupProbe has successfully completed.
		"restartPolicy"?: string

		// SecurityContext defines the security options the container
		// should be run with. If set, the fields of SecurityContext
		// override the equivalent fields of PodSecurityContext. More
		// info:
		// https://kubernetes.io/docs/tasks/configure-pod-container/security-context/
		"securityContext"?: #."io.k8s.api.core.v1.SecurityContext"

		// StartupProbe indicates that the Pod has successfully
		// initialized. If specified, no other probes are executed until
		// this completes successfully. If this probe fails, the Pod will
		// be restarted, just as if the livenessProbe failed. This can be
		// used to provide different probe parameters at the beginning of
		// a Pod's lifecycle, when it might take a long time to load data
		// or warm a cache, than during steady-state operation. This
		// cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"startupProbe"?: #."io.k8s.api.core.v1.Probe"

		// Whether this container should allocate a buffer for stdin in
		// the container runtime. If this is not set, reads from stdin in
		// the container will always result in EOF. Default is false.
		"stdin"?: bool

		// Whether the container runtime should close the stdin channel
		// after it has been opened by a single attach. When stdin is
		// true the stdin stream will remain open across multiple attach
		// sessions. If stdinOnce is set to true, stdin is opened on
		// container start, is empty until the first client attaches to
		// stdin, and then remains open and accepts data until the client
		// disconnects, at which time stdin is closed and remains closed
		// until the container is restarted. If this flag is false, a
		// container processes that reads from stdin will never receive
		// an EOF. Default is false
		"stdinOnce"?: bool

		// Optional: Path at which the file to which the container's
		// termination message will be written is mounted into the
		// container's filesystem. Message written is intended to be
		// brief final status, such as an assertion failure message. Will
		// be truncated by the node if greater than 4096 bytes. The total
		// message length across all containers will be limited to 12kb.
		// Defaults to /dev/termination-log. Cannot be updated.
		"terminationMessagePath"?: string

		// Indicate how the termination message should be populated. File
		// will use the contents of terminationMessagePath to populate
		// the container status message on both success and failure.
		// FallbackToLogsOnError will use the last chunk of container log
		// output if the termination message file is empty and the
		// container exited with an error. The log output is limited to
		// 2048 bytes or 80 lines, whichever is smaller. Defaults to
		// File. Cannot be updated.
		"terminationMessagePolicy"?: string

		// Whether this container should allocate a TTY for itself, also
		// requires 'stdin' to be true. Default is false.
		"tty"?: bool

		// volumeDevices is the list of block devices to be used by the
		// container.
		"volumeDevices"?: [...#."io.k8s.api.core.v1.VolumeDevice"]

		// Pod volumes to mount into the container's filesystem. Cannot be
		// updated.
		"volumeMounts"?: [...#."io.k8s.api.core.v1.VolumeMount"]

		// Container's working directory. If not specified, the container
		// runtime's default will be used, which might be configured in
		// the container image. Cannot be updated.
		"workingDir"?: string
	}

	// ContainerPort represents a network port in a single container.
	#: "io.k8s.api.core.v1.ContainerPort": {
		// Number of port to expose on the pod's IP address. This must be
		// a valid port number, 0 < x < 65536.
		"containerPort"!: int

		// What host IP to bind the external port to.
		"hostIP"?: string

		// Number of port to expose on the host. If specified, this must
		// be a valid port number, 0 < x < 65536. If HostNetwork is
		// specified, this must match ContainerPort. Most containers do
		// not need this.
		"hostPort"?: int

		// If specified, this must be an IANA_SVC_NAME and unique within
		// the pod. Each named port in a pod must have a unique name.
		// Name for the port that can be referred to by services.
		"name"?: string

		// Protocol for port. Must be UDP, TCP, or SCTP. Defaults to
		// "TCP".
		"protocol"?: string
	}

	// ContainerResizePolicy represents resource resize policy for the
	// container.
	#: "io.k8s.api.core.v1.ContainerResizePolicy": {
		// Name of the resource to which this resource resize policy
		// applies. Supported values: cpu, memory.
		"resourceName"!: string

		// Restart policy to apply when specified resource is resized. If
		// not specified, it defaults to NotRequired.
		"restartPolicy"!: string
	}

	// Represents downward API info for projecting into a projected
	// volume. Note that this is identical to a downwardAPI volume
	// source without the default mode.
	#: "io.k8s.api.core.v1.DownwardAPIProjection": {
		// Items is a list of DownwardAPIVolume file
		"items"?: [...#."io.k8s.api.core.v1.DownwardAPIVolumeFile"]
	}

	// DownwardAPIVolumeFile represents information to create the file
	// containing the pod field
	#: "io.k8s.api.core.v1.DownwardAPIVolumeFile": {
		// Required: Selects a field of the pod: only annotations, labels,
		// name, namespace and uid are supported.
		"fieldRef"?: #."io.k8s.api.core.v1.ObjectFieldSelector"

		// Optional: mode bits used to set permissions on this file, must
		// be an octal value between 0000 and 0777 or a decimal value
		// between 0 and 511. YAML accepts both octal and decimal values,
		// JSON requires decimal values for mode bits. If not specified,
		// the volume defaultMode will be used. This might be in conflict
		// with other options that affect the file mode, like fsGroup,
		// and the result can be other mode bits set.
		"mode"?: int

		// Required: Path is the relative path name of the file to be
		// created. Must not be absolute or contain the '..' path. Must
		// be utf-8 encoded. The first item of the relative path must not
		// start with '..'
		"path"!: string

		// Selects a resource of the container: only resources limits and
		// requests (limits.cpu, limits.memory, requests.cpu and
		// requests.memory) are currently supported.
		"resourceFieldRef"?: #."io.k8s.api.core.v1.ResourceFieldSelector"
	}

	// DownwardAPIVolumeSource represents a volume containing downward
	// API info. Downward API volumes support ownership management
	// and SELinux relabeling.
	#: "io.k8s.api.core.v1.DownwardAPIVolumeSource": {
		// Optional: mode bits to use on created files by default. Must be
		// a Optional: mode bits used to set permissions on created files
		// by default. Must be an octal value between 0000 and 0777 or a
		// decimal value between 0 and 511. YAML accepts both octal and
		// decimal values, JSON requires decimal values for mode bits.
		// Defaults to 0644. Directories within the path are not affected
		// by this setting. This might be in conflict with other options
		// that affect the file mode, like fsGroup, and the result can be
		// other mode bits set.
		"defaultMode"?: int

		// Items is a list of downward API volume file
		"items"?: [...#."io.k8s.api.core.v1.DownwardAPIVolumeFile"]
	}

	// Represents an empty directory for a pod. Empty directory
	// volumes support ownership management and SELinux relabeling.
	#: "io.k8s.api.core.v1.EmptyDirVolumeSource": {
		// medium represents what type of storage medium should back this
		// directory. The default is "" which means to use the node's
		// default medium. Must be an empty string (default) or Memory.
		// More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#emptydir
		"medium"?: string

		// sizeLimit is the total amount of local storage required for
		// this EmptyDir volume. The size limit is also applicable for
		// memory medium. The maximum usage on memory medium EmptyDir
		// would be the minimum value between the SizeLimit specified
		// here and the sum of memory limits of all containers in a pod.
		// The default is nil which means that the limit is undefined.
		// More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#emptydir
		"sizeLimit"?: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
	}

	// EnvFromSource represents the source of a set of ConfigMaps or
	// Secrets
	#: "io.k8s.api.core.v1.EnvFromSource": {
		// The ConfigMap to select from
		"configMapRef"?: #."io.k8s.api.core.v1.ConfigMapEnvSource"

		// Optional text to prepend to the name of each environment
		// variable. Must be a C_IDENTIFIER.
		"prefix"?: string

		// The Secret to select from
		"secretRef"?: #."io.k8s.api.core.v1.SecretEnvSource"
	}

	// EnvVar represents an environment variable present in a
	// Container.
	#: "io.k8s.api.core.v1.EnvVar": {
		// Name of the environment variable. Must be a C_IDENTIFIER.
		"name"!: string

		// Variable references $(VAR_NAME) are expanded using the
		// previously defined environment variables in the container and
		// any service environment variables. If a variable cannot be
		// resolved, the reference in the input string will be unchanged.
		// Double $$ are reduced to a single $, which allows for escaping
		// the $(VAR_NAME) syntax: i.e. "$$(VAR_NAME)" will produce the
		// string literal "$(VAR_NAME)". Escaped references will never be
		// expanded, regardless of whether the variable exists or not.
		// Defaults to "".
		"value"?: string

		// Source for the environment variable's value. Cannot be used if
		// value is not empty.
		"valueFrom"?: #."io.k8s.api.core.v1.EnvVarSource"
	}

	// EnvVarSource represents a source for the value of an EnvVar.
	#: "io.k8s.api.core.v1.EnvVarSource": {
		// Selects a key of a ConfigMap.
		"configMapKeyRef"?: #."io.k8s.api.core.v1.ConfigMapKeySelector"

		// Selects a field of the pod: supports metadata.name,
		// metadata.namespace, `metadata.labels['<KEY>']`,
		// `metadata.annotations['<KEY>']`, spec.nodeName,
		// spec.serviceAccountName, status.hostIP, status.podIP,
		// status.podIPs.
		"fieldRef"?: #."io.k8s.api.core.v1.ObjectFieldSelector"

		// Selects a resource of the container: only resources limits and
		// requests (limits.cpu, limits.memory, limits.ephemeral-storage,
		// requests.cpu, requests.memory and requests.ephemeral-storage)
		// are currently supported.
		"resourceFieldRef"?: #."io.k8s.api.core.v1.ResourceFieldSelector"

		// Selects a key of a secret in the pod's namespace
		"secretKeyRef"?: #."io.k8s.api.core.v1.SecretKeySelector"
	}

	// Represents an ephemeral volume that is handled by a normal
	// storage driver.
	#: "io.k8s.api.core.v1.EphemeralVolumeSource": {
		// Will be used to create a stand-alone PVC to provision the
		// volume. The pod in which this EphemeralVolumeSource is
		// embedded will be the owner of the PVC, i.e. the PVC will be
		// deleted together with the pod. The name of the PVC will be
		// `<pod name>-<volume name>` where `<volume name>` is the name
		// from the `PodSpec.Volumes` array entry. Pod validation will
		// reject the pod if the concatenated name is not valid for a PVC
		// (for example, too long).
		//
		// An existing PVC with that name that is not owned by the pod
		// will *not* be used for the pod to avoid using an unrelated
		// volume by mistake. Starting the pod is then blocked until the
		// unrelated PVC is removed. If such a pre-created PVC is meant
		// to be used by the pod, the PVC has to updated with an owner
		// reference to the pod once the pod exists. Normally this should
		// not be necessary, but it may be useful when manually
		// reconstructing a broken cluster.
		//
		// This field is read-only and no changes will be made by
		// Kubernetes to the PVC after it has been created.
		//
		// Required, must not be nil.
		"volumeClaimTemplate"?: #."io.k8s.api.core.v1.PersistentVolumeClaimTemplate"
	}

	// Event is a report of an event somewhere in the cluster. Events
	// have a limited retention time and triggers and messages may
	// evolve with time. Event consumers should not rely on the
	// timing of an event with a given Reason reflecting a consistent
	// underlying trigger, or the continued existence of events with
	// that Reason. Events should be treated as informative,
	// best-effort, supplemental data.
	#: "io.k8s.api.core.v1.Event": {
		// What action was taken/failed regarding to the Regarding object.
		"action"?: string

		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string

		// The number of times this event has occurred.
		"count"?: int

		// Time when this Event was first observed.
		"eventTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"

		// The time at which the event was first recorded. (Time of server
		// receipt is in TypeMeta.)
		"firstTimestamp"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// The object that this event is about.
		"involvedObject"!: #."io.k8s.api.core.v1.ObjectReference"

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?: string

		// The time at which the most recent occurrence of this event was
		// recorded.
		"lastTimestamp"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// A human-readable description of the status of this operation.
		"message"?: string

		// Standard object's metadata. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
		"metadata"!: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"

		// This should be a short, machine understandable string that
		// gives the reason for the transition into the object's current
		// status.
		"reason"?: string

		// Optional secondary object for more complex actions.
		"related"?: #."io.k8s.api.core.v1.ObjectReference"

		// Name of the controller that emitted this Event, e.g.
		// `kubernetes.io/kubelet`.
		"reportingComponent"?: string

		// ID of the controller instance, e.g. `kubelet-xyzf`.
		"reportingInstance"?: string

		// Data about the Event series this event represents or nil if
		// it's a singleton Event.
		"series"?: #."io.k8s.api.core.v1.EventSeries"

		// The component reporting this event. Should be a short machine
		// understandable string.
		"source"?: #."io.k8s.api.core.v1.EventSource"

		// Type of this event (Normal, Warning), new types could be added
		// in the future
		"type"?: string
	}

	// EventSeries contain information on series of events, i.e. thing
	// that was/is happening continuously for some time.
	#: "io.k8s.api.core.v1.EventSeries": {
		// Number of occurrences in this series up to the last heartbeat
		// time
		"count"?: int

		// Time of the last occurrence observed
		"lastObservedTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime"
	}

	// EventSource contains information for an event.
	#: "io.k8s.api.core.v1.EventSource": {
		// Component from which the event is generated.
		"component"?: string

		// Node name on which the event is generated.
		"host"?: string
	}

	// ExecAction describes a "run in container" action.
	#: "io.k8s.api.core.v1.ExecAction": {
		// Command is the command line to execute inside the container,
		// the working directory for the command is root ('/') in the
		// container's filesystem. The command is simply exec'd, it is
		// not run inside a shell, so traditional shell instructions
		// ('|', etc) won't work. To use a shell, you need to explicitly
		// call out to that shell. Exit status of 0 is treated as
		// live/healthy and non-zero is unhealthy.
		"command"?: [...string]
	}

	// Represents a Fibre Channel volume. Fibre Channel volumes can
	// only be mounted as read/write once. Fibre Channel volumes
	// support ownership management and SELinux relabeling.
	#: "io.k8s.api.core.v1.FCVolumeSource": {
		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Ex. "ext4",
		// "xfs", "ntfs". Implicitly inferred to be "ext4" if
		// unspecified.
		"fsType"?: string

		// lun is Optional: FC target lun number
		"lun"?: int

		// readOnly is Optional: Defaults to false (read/write). ReadOnly
		// here will force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// targetWWNs is Optional: FC target worldwide names (WWNs)
		"targetWWNs"?: [...string]

		// wwids Optional: FC volume world wide identifiers (wwids) Either
		// wwids or combination of targetWWNs and lun must be set, but
		// not both simultaneously.
		"wwids"?: [...string]
	}

	// FlexVolume represents a generic volume resource that is
	// provisioned/attached using an exec based plugin.
	#: "io.k8s.api.core.v1.FlexVolumeSource": {
		// driver is the name of the driver to use for this volume.
		"driver"!: string

		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Ex. "ext4",
		// "xfs", "ntfs". The default filesystem depends on FlexVolume
		// script.
		"fsType"?: string

		// options is Optional: this field holds extra command options if
		// any.
		"options"?: {
			[string]: string
		}

		// readOnly is Optional: defaults to false (read/write). ReadOnly
		// here will force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// secretRef is Optional: secretRef is reference to the secret
		// object containing sensitive information to pass to the plugin
		// scripts. This may be empty if no secret object is specified.
		// If the secret object contains more than one secret, all
		// secrets are passed to the plugin scripts.
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"
	}

	// Represents a Flocker volume mounted by the Flocker agent. One
	// and only one of datasetName and datasetUUID should be set.
	// Flocker volumes do not support ownership management or SELinux
	// relabeling.
	#: "io.k8s.api.core.v1.FlockerVolumeSource": {
		// datasetName is Name of the dataset stored as metadata -> name
		// on the dataset for Flocker should be considered as deprecated
		"datasetName"?: string

		// datasetUUID is the UUID of the dataset. This is unique
		// identifier of a Flocker dataset
		"datasetUUID"?: string
	}

	// Represents a Persistent Disk resource in Google Compute Engine.
	//
	// A GCE PD must exist before mounting to a container. The disk
	// must also be in the same GCE project and zone as the kubelet.
	// A GCE PD can only be mounted as read/write once or read-only
	// many times. GCE PDs support ownership management and SELinux
	// relabeling.
	#: "io.k8s.api.core.v1.GCEPersistentDiskVolumeSource": {
		// fsType is filesystem type of the volume that you want to mount.
		// Tip: Ensure that the filesystem type is supported by the host
		// operating system. Examples: "ext4", "xfs", "ntfs". Implicitly
		// inferred to be "ext4" if unspecified. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
		"fsType"?: string

		// partition is the partition in the volume that you want to
		// mount. If omitted, the default is to mount by volume name.
		// Examples: For volume /dev/sda1, you specify the partition as
		// "1". Similarly, the volume partition for /dev/sda is "0" (or
		// you can leave the property empty). More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
		"partition"?: int

		// pdName is unique name of the PD resource in GCE. Used to
		// identify the disk in GCE. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
		"pdName"!: string

		// readOnly here will force the ReadOnly setting in VolumeMounts.
		// Defaults to false. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
		"readOnly"?: bool
	}

	// GRPCAction specifies an action involving a GRPC service.
	#: "io.k8s.api.core.v1.GRPCAction": {
		// Port number of the gRPC service. Number must be in the range 1
		// to 65535.
		"port"!: int

		// Service is the name of the service to place in the gRPC
		// HealthCheckRequest (see
		// https://github.com/grpc/grpc/blob/master/doc/health-checking.md).
		//
		// If this is not specified, the default behavior is defined by
		// gRPC.
		"service"?: string
	}

	// Represents a volume that is populated with the contents of a
	// git repository. Git repo volumes do not support ownership
	// management. Git repo volumes support SELinux relabeling.
	//
	// DEPRECATED: GitRepo is deprecated. To provision a container
	// with a git repo, mount an EmptyDir into an InitContainer that
	// clones the repo using git, then mount the EmptyDir into the
	// Pod's container.
	#: "io.k8s.api.core.v1.GitRepoVolumeSource": {
		// directory is the target directory name. Must not contain or
		// start with '..'. If '.' is supplied, the volume directory will
		// be the git repository. Otherwise, if specified, the volume
		// will contain the git repository in the subdirectory with the
		// given name.
		"directory"?: string

		// repository is the URL
		"repository"!: string

		// revision is the commit hash for the specified revision.
		"revision"?: string
	}

	// Represents a Glusterfs mount that lasts the lifetime of a pod.
	// Glusterfs volumes do not support ownership management or
	// SELinux relabeling.
	#: "io.k8s.api.core.v1.GlusterfsVolumeSource": {
		// endpoints is the endpoint name that details Glusterfs topology.
		// More info:
		// https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod
		"endpoints"!: string

		// path is the Glusterfs volume path. More info:
		// https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod
		"path"!: string

		// readOnly here will force the Glusterfs volume to be mounted
		// with read-only permissions. Defaults to false. More info:
		// https://examples.k8s.io/volumes/glusterfs/README.md#create-a-pod
		"readOnly"?: bool
	}

	// HTTPGetAction describes an action based on HTTP Get requests.
	#: "io.k8s.api.core.v1.HTTPGetAction": {
		// Host name to connect to, defaults to the pod IP. You probably
		// want to set "Host" in httpHeaders instead.
		"host"?: string

		// Custom headers to set in the request. HTTP allows repeated
		// headers.
		"httpHeaders"?: [...#."io.k8s.api.core.v1.HTTPHeader"]

		// Path to access on the HTTP server.
		"path"?: string

		// Name or number of the port to access on the container. Number
		// must be in the range 1 to 65535. Name must be an
		// IANA_SVC_NAME.
		"port"!: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// Scheme to use for connecting to the host. Defaults to HTTP.
		"scheme"?: string
	}

	// HTTPHeader describes a custom header to be used in HTTP probes
	#: "io.k8s.api.core.v1.HTTPHeader": {
		// The header field name. This will be canonicalized upon output,
		// so case-variant names will be understood as the same header.
		"name"!: string

		// The header field value
		"value"!: string
	}

	// HostAlias holds the mapping between IP and hostnames that will
	// be injected as an entry in the pod's hosts file.
	#: "io.k8s.api.core.v1.HostAlias": {
		// Hostnames for the above IP address.
		"hostnames"?: [...string]

		// IP address of the host file entry.
		"ip"!: string
	}

	// Represents a host path mapped into a pod. Host path volumes do
	// not support ownership management or SELinux relabeling.
	#: "io.k8s.api.core.v1.HostPathVolumeSource": {
		// path of the directory on the host. If the path is a symlink, it
		// will follow the link to the real path. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#hostpath
		"path"!: string

		// type for HostPath Volume Defaults to "" More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#hostpath
		"type"?: string
	}

	// Represents an ISCSI disk. ISCSI volumes can only be mounted as
	// read/write once. ISCSI volumes support ownership management
	// and SELinux relabeling.
	#: "io.k8s.api.core.v1.ISCSIVolumeSource": {
		// chapAuthDiscovery defines whether support iSCSI Discovery CHAP
		// authentication
		"chapAuthDiscovery"?: bool

		// chapAuthSession defines whether support iSCSI Session CHAP
		// authentication
		"chapAuthSession"?: bool

		// fsType is the filesystem type of the volume that you want to
		// mount. Tip: Ensure that the filesystem type is supported by
		// the host operating system. Examples: "ext4", "xfs", "ntfs".
		// Implicitly inferred to be "ext4" if unspecified. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#iscsi
		"fsType"?: string

		// initiatorName is the custom iSCSI Initiator Name. If
		// initiatorName is specified with iscsiInterface simultaneously,
		// new iSCSI interface <target portal>:<volume name> will be
		// created for the connection.
		"initiatorName"?: string

		// iqn is the target iSCSI Qualified Name.
		"iqn"!: string

		// iscsiInterface is the interface Name that uses an iSCSI
		// transport. Defaults to 'default' (tcp).
		"iscsiInterface"?: string

		// lun represents iSCSI Target Lun number.
		"lun"!: int

		// portals is the iSCSI Target Portal List. The portal is either
		// an IP or ip_addr:port if the port is other than default
		// (typically TCP ports 860 and 3260).
		"portals"?: [...string]

		// readOnly here will force the ReadOnly setting in VolumeMounts.
		// Defaults to false.
		"readOnly"?: bool

		// secretRef is the CHAP Secret for iSCSI target and initiator
		// authentication
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// targetPortal is iSCSI Target Portal. The Portal is either an IP
		// or ip_addr:port if the port is other than default (typically
		// TCP ports 860 and 3260).
		"targetPortal"!: string
	}

	// ImageVolumeSource represents a image volume resource.
	#: "io.k8s.api.core.v1.ImageVolumeSource": {
		// Policy for pulling OCI objects. Possible values are: Always:
		// the kubelet always attempts to pull the reference. Container
		// creation will fail If the pull fails. Never: the kubelet never
		// pulls the reference and only uses a local image or artifact.
		// Container creation will fail if the reference isn't present.
		// IfNotPresent: the kubelet pulls if the reference isn't already
		// present on disk. Container creation will fail if the reference
		// isn't present and the pull fails. Defaults to Always if
		// :latest tag is specified, or IfNotPresent otherwise.
		"pullPolicy"?: string

		// Required: Image or artifact reference to be used. Behaves in
		// the same way as pod.spec.containers[*].image. Pull secrets
		// will be assembled in the same way as for the container image
		// by looking up node credentials, SA image pull secrets, and pod
		// spec image pull secrets. More info:
		// https://kubernetes.io/docs/concepts/containers/images This
		// field is optional to allow higher level config management to
		// default or override container images in workload controllers
		// like Deployments and StatefulSets.
		"reference"?: string
	}

	// Maps a string key to a path within a volume.
	#: "io.k8s.api.core.v1.KeyToPath": {
		// key is the key to project.
		"key"!: string

		// mode is Optional: mode bits used to set permissions on this
		// file. Must be an octal value between 0000 and 0777 or a
		// decimal value between 0 and 511. YAML accepts both octal and
		// decimal values, JSON requires decimal values for mode bits. If
		// not specified, the volume defaultMode will be used. This might
		// be in conflict with other options that affect the file mode,
		// like fsGroup, and the result can be other mode bits set.
		"mode"?: int

		// path is the relative path of the file to map the key to. May
		// not be an absolute path. May not contain the path element
		// '..'. May not start with the string '..'.
		"path"!: string
	}

	// Lifecycle describes actions that the management system should
	// take in response to container lifecycle events. For the
	// PostStart and PreStop lifecycle handlers, management of the
	// container blocks until the action is complete, unless the
	// container process fails, in which case the handler is aborted.
	#: "io.k8s.api.core.v1.Lifecycle": {
		// PostStart is called immediately after a container is created.
		// If the handler fails, the container is terminated and
		// restarted according to its restart policy. Other management of
		// the container blocks until the hook completes. More info:
		// https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
		"postStart"?: #."io.k8s.api.core.v1.LifecycleHandler"

		// PreStop is called immediately before a container is terminated
		// due to an API request or management event such as
		// liveness/startup probe failure, preemption, resource
		// contention, etc. The handler is not called if the container
		// crashes or exits. The Pod's termination grace period countdown
		// begins before the PreStop hook is executed. Regardless of the
		// outcome of the handler, the container will eventually
		// terminate within the Pod's termination grace period (unless
		// delayed by finalizers). Other management of the container
		// blocks until the hook completes or until the termination grace
		// period is reached. More info:
		// https://kubernetes.io/docs/concepts/containers/container-lifecycle-hooks/#container-hooks
		"preStop"?: #."io.k8s.api.core.v1.LifecycleHandler"

		// StopSignal defines which signal will be sent to a container
		// when it is being stopped. If not specified, the default is
		// defined by the container runtime in use. StopSignal can only
		// be set for Pods with a non-empty .spec.os.name
		"stopSignal"?: string
	}

	// LifecycleHandler defines a specific action that should be taken
	// in a lifecycle hook. One and only one of the fields, except
	// TCPSocket must be specified.
	#: "io.k8s.api.core.v1.LifecycleHandler": {
		// Exec specifies a command to execute in the container.
		"exec"?: #."io.k8s.api.core.v1.ExecAction"

		// HTTPGet specifies an HTTP GET request to perform.
		"httpGet"?: #."io.k8s.api.core.v1.HTTPGetAction"

		// Sleep represents a duration that the container should sleep.
		"sleep"?: #."io.k8s.api.core.v1.SleepAction"

		// Deprecated. TCPSocket is NOT supported as a LifecycleHandler
		// and kept for backward compatibility. There is no validation of
		// this field and lifecycle hooks will fail at runtime when it is
		// specified.
		"tcpSocket"?: #."io.k8s.api.core.v1.TCPSocketAction"
	}

	// LocalObjectReference contains enough information to let you
	// locate the referenced object inside the same namespace.
	#: "io.k8s.api.core.v1.LocalObjectReference": {
		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string
	}

	// ModifyVolumeStatus represents the status object of
	// ControllerModifyVolume operation
	#: "io.k8s.api.core.v1.ModifyVolumeStatus": {
		// status is the status of the ControllerModifyVolume operation.
		// It can be in any of following states:
		// - Pending
		// Pending indicates that the PersistentVolumeClaim cannot be
		// modified due to unmet requirements, such as
		// the specified VolumeAttributesClass not existing.
		// - InProgress
		// InProgress indicates that the volume is being modified.
		// - Infeasible
		// Infeasible indicates that the request has been rejected as
		// invalid by the CSI driver. To
		// resolve the error, a valid VolumeAttributesClass needs to be
		// specified.
		// Note: New statuses can be added in the future. Consumers should
		// check for unknown statuses and fail appropriately.
		"status"!: string

		// targetVolumeAttributesClassName is the name of the
		// VolumeAttributesClass the PVC currently being reconciled
		"targetVolumeAttributesClassName"?: string
	}

	// Represents an NFS mount that lasts the lifetime of a pod. NFS
	// volumes do not support ownership management or SELinux
	// relabeling.
	#: "io.k8s.api.core.v1.NFSVolumeSource": {
		// path that is exported by the NFS server. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#nfs
		"path"!: string

		// readOnly here will force the NFS export to be mounted with
		// read-only permissions. Defaults to false. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#nfs
		"readOnly"?: bool

		// server is the hostname or IP address of the NFS server. More
		// info: https://kubernetes.io/docs/concepts/storage/volumes#nfs
		"server"!: string
	}

	// Node affinity is a group of node affinity scheduling rules.
	#: "io.k8s.api.core.v1.NodeAffinity": {
		// The scheduler will prefer to schedule pods to nodes that
		// satisfy the affinity expressions specified by this field, but
		// it may choose a node that violates one or more of the
		// expressions. The node that is most preferred is the one with
		// the greatest sum of weights, i.e. for each node that meets all
		// of the scheduling requirements (resource request,
		// requiredDuringScheduling affinity expressions, etc.), compute
		// a sum by iterating through the elements of this field and
		// adding "weight" to the sum if the node matches the
		// corresponding matchExpressions; the node(s) with the highest
		// sum are the most preferred.
		"preferredDuringSchedulingIgnoredDuringExecution"?: [...#."io.k8s.api.core.v1.PreferredSchedulingTerm"]

		// If the affinity requirements specified by this field are not
		// met at scheduling time, the pod will not be scheduled onto the
		// node. If the affinity requirements specified by this field
		// cease to be met at some point during pod execution (e.g. due
		// to an update), the system may or may not try to eventually
		// evict the pod from its node.
		"requiredDuringSchedulingIgnoredDuringExecution"?: #."io.k8s.api.core.v1.NodeSelector"
	}

	// A node selector represents the union of the results of one or
	// more label queries over a set of nodes; that is, it represents
	// the OR of the selectors represented by the node selector
	// terms.
	#: "io.k8s.api.core.v1.NodeSelector": {
		// Required. A list of node selector terms. The terms are ORed.
		"nodeSelectorTerms"!: [...#."io.k8s.api.core.v1.NodeSelectorTerm"]
	}

	// A node selector requirement is a selector that contains values,
	// a key, and an operator that relates the key and values.
	#: "io.k8s.api.core.v1.NodeSelectorRequirement": {
		// The label key that the selector applies to.
		"key"!: string

		// Represents a key's relationship to a set of values. Valid
		// operators are In, NotIn, Exists, DoesNotExist. Gt, and Lt.
		"operator"!: string

		// An array of string values. If the operator is In or NotIn, the
		// values array must be non-empty. If the operator is Exists or
		// DoesNotExist, the values array must be empty. If the operator
		// is Gt or Lt, the values array must have a single element,
		// which will be interpreted as an integer. This array is
		// replaced during a strategic merge patch.
		"values"?: [...string]
	}

	// A null or empty node selector term matches no objects. The
	// requirements of them are ANDed. The TopologySelectorTerm type
	// implements a subset of the NodeSelectorTerm.
	#: "io.k8s.api.core.v1.NodeSelectorTerm": {
		// A list of node selector requirements by node's labels.
		"matchExpressions"?: [...#."io.k8s.api.core.v1.NodeSelectorRequirement"]

		// A list of node selector requirements by node's fields.
		"matchFields"?: [...#."io.k8s.api.core.v1.NodeSelectorRequirement"]
	}

	// ObjectFieldSelector selects an APIVersioned field of an object.
	#: "io.k8s.api.core.v1.ObjectFieldSelector": {
		// Version of the schema the FieldPath is written in terms of,
		// defaults to "v1".
		"apiVersion"?: string

		// Path of the field to select in the specified API version.
		"fieldPath"!: string
	}

	// ObjectReference contains enough information to let you inspect
	// or modify the referred object.
	#: "io.k8s.api.core.v1.ObjectReference": {
		// API version of the referent.
		"apiVersion"?: string

		// If referring to a piece of an object instead of an entire
		// object, this string should contain a valid JSON/Go field
		// access statement, such as desiredState.manifest.containers[2].
		// For example, if the object reference is to a container within
		// a pod, this would take on a value like:
		// "spec.containers{name}" (where "name" refers to the name of
		// the container that triggered the event) or if no container
		// name is specified "spec.containers[2]" (container with index 2
		// in this pod). This syntax is chosen only to have some
		// well-defined way of referencing a part of an object.
		"fieldPath"?: string

		// Kind of the referent. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?: string

		// Name of the referent. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// Namespace of the referent. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces/
		"namespace"?: string

		// Specific resourceVersion to which this reference is made, if
		// any. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
		"resourceVersion"?: string

		// UID of the referent. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#uids
		"uid"?: string
	}

	// PersistentVolumeClaim is a user's request for and claim to a
	// persistent volume
	#: "io.k8s.api.core.v1.PersistentVolumeClaim": {
		// APIVersion defines the versioned schema of this representation
		// of an object. Servers should convert recognized schemas to the
		// latest internal value, and may reject unrecognized values.
		// More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#resources
		"apiVersion"?: string

		// Kind is a string value representing the REST resource this
		// object represents. Servers may infer this from the endpoint
		// the client submits requests to. Cannot be updated. In
		// CamelCase. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"?: string

		// Standard object's metadata. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"

		// spec defines the desired characteristics of a volume requested
		// by a pod author. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
		"spec"?: #."io.k8s.api.core.v1.PersistentVolumeClaimSpec"

		// status represents the current information/status of a
		// persistent volume claim. Read-only. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
		"status"?: #."io.k8s.api.core.v1.PersistentVolumeClaimStatus"
	}

	// PersistentVolumeClaimCondition contains details about state of
	// pvc
	#: "io.k8s.api.core.v1.PersistentVolumeClaimCondition": {
		// lastProbeTime is the time we probed the condition.
		"lastProbeTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// lastTransitionTime is the time the condition transitioned from
		// one status to another.
		"lastTransitionTime"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// message is the human-readable message indicating details about
		// last transition.
		"message"?: string

		// reason is a unique, this should be a short, machine
		// understandable string that gives the reason for condition's
		// last transition. If it reports "Resizing" that means the
		// underlying persistent volume is being resized.
		"reason"?: string

		// Status is the status of the condition. Can be True, False,
		// Unknown. More info:
		// https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=state%20of%20pvc-,conditions.status,-(string)%2C%20required
		"status"!: string

		// Type is the type of the condition. More info:
		// https://kubernetes.io/docs/reference/kubernetes-api/config-and-storage-resources/persistent-volume-claim-v1/#:~:text=set%20to%20%27ResizeStarted%27.-,PersistentVolumeClaimCondition,-contains%20details%20about
		"type"!: string
	}

	// PersistentVolumeClaimSpec describes the common attributes of
	// storage devices and allows a Source for provider-specific
	// attributes
	#: "io.k8s.api.core.v1.PersistentVolumeClaimSpec": {
		// accessModes contains the desired access modes the volume should
		// have. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1
		"accessModes"?: [...string]

		// dataSource field can be used to specify either: * An existing
		// VolumeSnapshot object (snapshot.storage.k8s.io/VolumeSnapshot)
		// * An existing PVC (PersistentVolumeClaim) If the provisioner
		// or an external controller can support the specified data
		// source, it will create a new volume based on the contents of
		// the specified data source. When the AnyVolumeDataSource
		// feature gate is enabled, dataSource contents will be copied to
		// dataSourceRef, and dataSourceRef contents will be copied to
		// dataSource when dataSourceRef.namespace is not specified. If
		// the namespace is specified, then dataSourceRef will not be
		// copied to dataSource.
		"dataSource"?: #."io.k8s.api.core.v1.TypedLocalObjectReference"

		// dataSourceRef specifies the object from which to populate the
		// volume with data, if a non-empty volume is desired. This may
		// be any object from a non-empty API group (non core object) or
		// a PersistentVolumeClaim object. When this field is specified,
		// volume binding will only succeed if the type of the specified
		// object matches some installed volume populator or dynamic
		// provisioner. This field will replace the functionality of the
		// dataSource field and as such if both fields are non-empty,
		// they must have the same value. For backwards compatibility,
		// when namespace isn't specified in dataSourceRef, both fields
		// (dataSource and dataSourceRef) will be set to the same value
		// automatically if one of them is empty and the other is
		// non-empty. When namespace is specified in dataSourceRef,
		// dataSource isn't set to the same value and must be empty.
		// There are three important differences between dataSource and
		// dataSourceRef: * While dataSource only allows two specific
		// types of objects, dataSourceRef
		// allows any non-core object, as well as PersistentVolumeClaim
		// objects.
		// * While dataSource ignores disallowed values (dropping them),
		// dataSourceRef
		// preserves all values, and generates an error if a disallowed
		// value is
		// specified.
		// * While dataSource only allows local objects, dataSourceRef
		// allows objects
		// in any namespaces.
		// (Beta) Using this field requires the AnyVolumeDataSource
		// feature gate to be enabled. (Alpha) Using the namespace field
		// of dataSourceRef requires the CrossNamespaceVolumeDataSource
		// feature gate to be enabled.
		"dataSourceRef"?: #."io.k8s.api.core.v1.TypedObjectReference"

		// resources represents the minimum resources the volume should
		// have. If RecoverVolumeExpansionFailure feature is enabled
		// users are allowed to specify resource requirements that are
		// lower than previous value but must still be higher than
		// capacity recorded in the status field of the claim. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources
		"resources"?: #."io.k8s.api.core.v1.VolumeResourceRequirements"

		// selector is a label query over volumes to consider for binding.
		"selector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// storageClassName is the name of the StorageClass required by
		// the claim. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1
		"storageClassName"?: string

		// volumeAttributesClassName may be used to set the
		// VolumeAttributesClass used by this claim. If specified, the
		// CSI driver will create or update the volume with the
		// attributes defined in the corresponding VolumeAttributesClass.
		// This has a different purpose than storageClassName, it can be
		// changed after the claim is created. An empty string value
		// means that no VolumeAttributesClass will be applied to the
		// claim but it's not allowed to reset this field to empty string
		// once it is set. If unspecified and the PersistentVolumeClaim
		// is unbound, the default VolumeAttributesClass will be set by
		// the persistentvolume controller if it exists. If the resource
		// referred to by volumeAttributesClass does not exist, this
		// PersistentVolumeClaim will be set to a Pending state, as
		// reflected by the modifyVolumeStatus field, until such as a
		// resource exists. More info:
		// https://kubernetes.io/docs/concepts/storage/volume-attributes-classes/
		// (Beta) Using this field requires the VolumeAttributesClass
		// feature gate to be enabled (off by default).
		"volumeAttributesClassName"?: string

		// volumeMode defines what type of volume is required by the
		// claim. Value of Filesystem is implied when not included in
		// claim spec.
		"volumeMode"?: string

		// volumeName is the binding reference to the PersistentVolume
		// backing this claim.
		"volumeName"?: string
	}

	// PersistentVolumeClaimStatus is the current status of a
	// persistent volume claim.
	#: "io.k8s.api.core.v1.PersistentVolumeClaimStatus": {
		// accessModes contains the actual access modes the volume backing
		// the PVC has. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1
		"accessModes"?: [...string]

		// allocatedResourceStatuses stores status of resource being
		// resized for the given PVC. Key names follow standard
		// Kubernetes label syntax. Valid values are either:
		// * Un-prefixed keys:
		// - storage - the capacity of the volume.
		// * Custom resources must use implementation-defined prefixed
		// names such as "example.com/my-custom-resource"
		// Apart from above values - keys that are unprefixed or have
		// kubernetes.io prefix are considered reserved and hence may not
		// be used.
		//
		// ClaimResourceStatus can be in any of following states:
		// - ControllerResizeInProgress:
		// State set when resize controller starts resizing the volume in
		// control-plane.
		// - ControllerResizeFailed:
		// State set when resize has failed in resize controller with a
		// terminal error.
		// - NodeResizePending:
		// State set when resize controller has finished resizing the
		// volume but further resizing of
		// volume is needed on the node.
		// - NodeResizeInProgress:
		// State set when kubelet starts resizing the volume.
		// - NodeResizeFailed:
		// State set when resizing has failed in kubelet with a terminal
		// error. Transient errors don't set
		// NodeResizeFailed.
		// For example: if expanding a PVC for more capacity - this field
		// can be one of the following states:
		// - pvc.status.allocatedResourceStatus['storage'] =
		// "ControllerResizeInProgress"
		// - pvc.status.allocatedResourceStatus['storage'] =
		// "ControllerResizeFailed"
		// - pvc.status.allocatedResourceStatus['storage'] =
		// "NodeResizePending"
		// - pvc.status.allocatedResourceStatus['storage'] =
		// "NodeResizeInProgress"
		// - pvc.status.allocatedResourceStatus['storage'] =
		// "NodeResizeFailed"
		// When this field is not set, it means that no resize operation
		// is in progress for the given PVC.
		//
		// A controller that receives PVC update with previously unknown
		// resourceName or ClaimResourceStatus should ignore the update
		// for the purpose it was designed. For example - a controller
		// that only is responsible for resizing capacity of the volume,
		// should ignore PVC updates that change other valid resources
		// associated with PVC.
		//
		// This is an alpha field and requires enabling
		// RecoverVolumeExpansionFailure feature.
		"allocatedResourceStatuses"?: {
			[string]: string
		}

		// allocatedResources tracks the resources allocated to a PVC
		// including its capacity. Key names follow standard Kubernetes
		// label syntax. Valid values are either:
		// * Un-prefixed keys:
		// - storage - the capacity of the volume.
		// * Custom resources must use implementation-defined prefixed
		// names such as "example.com/my-custom-resource"
		// Apart from above values - keys that are unprefixed or have
		// kubernetes.io prefix are considered reserved and hence may not
		// be used.
		//
		// Capacity reported here may be larger than the actual capacity
		// when a volume expansion operation is requested. For storage
		// quota, the larger value from allocatedResources and
		// PVC.spec.resources is used. If allocatedResources is not set,
		// PVC.spec.resources alone is used for quota calculation. If a
		// volume expansion capacity request is lowered,
		// allocatedResources is only lowered if there are no expansion
		// operations in progress and if the actual volume capacity is
		// equal or lower than the requested capacity.
		//
		// A controller that receives PVC update with previously unknown
		// resourceName should ignore the update for the purpose it was
		// designed. For example - a controller that only is responsible
		// for resizing capacity of the volume, should ignore PVC updates
		// that change other valid resources associated with PVC.
		//
		// This is an alpha field and requires enabling
		// RecoverVolumeExpansionFailure feature.
		"allocatedResources"?: {
			[string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
		}

		// capacity represents the actual resources of the underlying
		// volume.
		"capacity"?: {
			[string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
		}

		// conditions is the current Condition of persistent volume claim.
		// If underlying persistent volume is being resized then the
		// Condition will be set to 'Resizing'.
		"conditions"?: [...#."io.k8s.api.core.v1.PersistentVolumeClaimCondition"]

		// currentVolumeAttributesClassName is the current name of the
		// VolumeAttributesClass the PVC is using. When unset, there is
		// no VolumeAttributeClass applied to this PersistentVolumeClaim
		// This is a beta field and requires enabling
		// VolumeAttributesClass feature (off by default).
		"currentVolumeAttributesClassName"?: string

		// ModifyVolumeStatus represents the status object of
		// ControllerModifyVolume operation. When this is unset, there is
		// no ModifyVolume operation being attempted. This is a beta
		// field and requires enabling VolumeAttributesClass feature (off
		// by default).
		"modifyVolumeStatus"?: #."io.k8s.api.core.v1.ModifyVolumeStatus"

		// phase represents the current phase of PersistentVolumeClaim.
		"phase"?: string
	}

	// PersistentVolumeClaimTemplate is used to produce
	// PersistentVolumeClaim objects as part of an
	// EphemeralVolumeSource.
	#: "io.k8s.api.core.v1.PersistentVolumeClaimTemplate": {
		// May contain labels and annotations that will be copied into the
		// PVC when creating it. No other fields are allowed and will be
		// rejected during validation.
		"metadata"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta"

		// The specification for the PersistentVolumeClaim. The entire
		// content is copied unchanged into the PVC that gets created
		// from this template. The same fields as in a
		// PersistentVolumeClaim are also valid here.
		"spec"!: #."io.k8s.api.core.v1.PersistentVolumeClaimSpec"
	}

	// PersistentVolumeClaimVolumeSource references the user's PVC in
	// the same namespace. This volume finds the bound PV and mounts
	// that volume for the pod. A PersistentVolumeClaimVolumeSource
	// is, essentially, a wrapper around another type of volume that
	// is owned by someone else (the system).
	#: "io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource": {
		// claimName is the name of a PersistentVolumeClaim in the same
		// namespace as the pod using this volume. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
		"claimName"!: string

		// readOnly Will force the ReadOnly setting in VolumeMounts.
		// Default false.
		"readOnly"?: bool
	}

	// Represents a Photon Controller persistent disk resource.
	#: "io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource": {
		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Ex. "ext4",
		// "xfs", "ntfs". Implicitly inferred to be "ext4" if
		// unspecified.
		"fsType"?: string

		// pdID is the ID that identifies Photon Controller persistent
		// disk
		"pdID"!: string
	}

	// Pod affinity is a group of inter pod affinity scheduling rules.
	#: "io.k8s.api.core.v1.PodAffinity": {
		// The scheduler will prefer to schedule pods to nodes that
		// satisfy the affinity expressions specified by this field, but
		// it may choose a node that violates one or more of the
		// expressions. The node that is most preferred is the one with
		// the greatest sum of weights, i.e. for each node that meets all
		// of the scheduling requirements (resource request,
		// requiredDuringScheduling affinity expressions, etc.), compute
		// a sum by iterating through the elements of this field and
		// adding "weight" to the sum if the node has pods which matches
		// the corresponding podAffinityTerm; the node(s) with the
		// highest sum are the most preferred.
		"preferredDuringSchedulingIgnoredDuringExecution"?: [...#."io.k8s.api.core.v1.WeightedPodAffinityTerm"]

		// If the affinity requirements specified by this field are not
		// met at scheduling time, the pod will not be scheduled onto the
		// node. If the affinity requirements specified by this field
		// cease to be met at some point during pod execution (e.g. due
		// to a pod label update), the system may or may not try to
		// eventually evict the pod from its node. When there are
		// multiple elements, the lists of nodes corresponding to each
		// podAffinityTerm are intersected, i.e. all terms must be
		// satisfied.
		"requiredDuringSchedulingIgnoredDuringExecution"?: [...#."io.k8s.api.core.v1.PodAffinityTerm"]
	}

	// Defines a set of pods (namely those matching the labelSelector
	// relative to the given namespace(s)) that this pod should be
	// co-located (affinity) or not co-located (anti-affinity) with,
	// where co-located is defined as running on a node whose value
	// of the label with key <topologyKey> matches that of any node
	// on which a pod of the set of pods is running
	#: "io.k8s.api.core.v1.PodAffinityTerm": {
		// A label query over a set of resources, in this case pods. If
		// it's null, this PodAffinityTerm matches with no Pods.
		"labelSelector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// MatchLabelKeys is a set of pod label keys to select which pods
		// will be taken into consideration. The keys are used to lookup
		// values from the incoming pod labels, those key-value labels
		// are merged with `labelSelector` as `key in (value)` to select
		// the group of existing pods which pods will be taken into
		// consideration for the incoming pod's pod (anti) affinity. Keys
		// that don't exist in the incoming pod labels will be ignored.
		// The default value is empty. The same key is forbidden to exist
		// in both matchLabelKeys and labelSelector. Also, matchLabelKeys
		// cannot be set when labelSelector isn't set.
		"matchLabelKeys"?: [...string]

		// MismatchLabelKeys is a set of pod label keys to select which
		// pods will be taken into consideration. The keys are used to
		// lookup values from the incoming pod labels, those key-value
		// labels are merged with `labelSelector` as `key notin (value)`
		// to select the group of existing pods which pods will be taken
		// into consideration for the incoming pod's pod (anti) affinity.
		// Keys that don't exist in the incoming pod labels will be
		// ignored. The default value is empty. The same key is forbidden
		// to exist in both mismatchLabelKeys and labelSelector. Also,
		// mismatchLabelKeys cannot be set when labelSelector isn't set.
		"mismatchLabelKeys"?: [...string]

		// A label query over the set of namespaces that the term applies
		// to. The term is applied to the union of the namespaces
		// selected by this field and the ones listed in the namespaces
		// field. null selector and null or empty namespaces list means
		// "this pod's namespace". An empty selector ({}) matches all
		// namespaces.
		"namespaceSelector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// namespaces specifies a static list of namespace names that the
		// term applies to. The term is applied to the union of the
		// namespaces listed in this field and the ones selected by
		// namespaceSelector. null or empty namespaces list and null
		// namespaceSelector means "this pod's namespace".
		"namespaces"?: [...string]

		// This pod should be co-located (affinity) or not co-located
		// (anti-affinity) with the pods matching the labelSelector in
		// the specified namespaces, where co-located is defined as
		// running on a node whose value of the label with key
		// topologyKey matches that of any node on which any of the
		// selected pods is running. Empty topologyKey is not allowed.
		"topologyKey"!: string
	}

	// Pod anti affinity is a group of inter pod anti affinity
	// scheduling rules.
	#: "io.k8s.api.core.v1.PodAntiAffinity": {
		// The scheduler will prefer to schedule pods to nodes that
		// satisfy the anti-affinity expressions specified by this field,
		// but it may choose a node that violates one or more of the
		// expressions. The node that is most preferred is the one with
		// the greatest sum of weights, i.e. for each node that meets all
		// of the scheduling requirements (resource request,
		// requiredDuringScheduling anti-affinity expressions, etc.),
		// compute a sum by iterating through the elements of this field
		// and adding "weight" to the sum if the node has pods which
		// matches the corresponding podAffinityTerm; the node(s) with
		// the highest sum are the most preferred.
		"preferredDuringSchedulingIgnoredDuringExecution"?: [...#."io.k8s.api.core.v1.WeightedPodAffinityTerm"]

		// If the anti-affinity requirements specified by this field are
		// not met at scheduling time, the pod will not be scheduled onto
		// the node. If the anti-affinity requirements specified by this
		// field cease to be met at some point during pod execution (e.g.
		// due to a pod label update), the system may or may not try to
		// eventually evict the pod from its node. When there are
		// multiple elements, the lists of nodes corresponding to each
		// podAffinityTerm are intersected, i.e. all terms must be
		// satisfied.
		"requiredDuringSchedulingIgnoredDuringExecution"?: [...#."io.k8s.api.core.v1.PodAffinityTerm"]
	}

	// PodDNSConfig defines the DNS parameters of a pod in addition to
	// those generated from DNSPolicy.
	#: "io.k8s.api.core.v1.PodDNSConfig": {
		// A list of DNS name server IP addresses. This will be appended
		// to the base nameservers generated from DNSPolicy. Duplicated
		// nameservers will be removed.
		"nameservers"?: [...string]

		// A list of DNS resolver options. This will be merged with the
		// base options generated from DNSPolicy. Duplicated entries will
		// be removed. Resolution options given in Options will override
		// those that appear in the base DNSPolicy.
		"options"?: [...#."io.k8s.api.core.v1.PodDNSConfigOption"]

		// A list of DNS search domains for host-name lookup. This will be
		// appended to the base search paths generated from DNSPolicy.
		// Duplicated search paths will be removed.
		"searches"?: [...string]
	}

	// PodDNSConfigOption defines DNS resolver options of a pod.
	#: "io.k8s.api.core.v1.PodDNSConfigOption": {
		// Name is this DNS resolver option's name. Required.
		"name"?: string

		// Value is this DNS resolver option's value.
		"value"?: string
	}

	// PodSecurityContext holds pod-level security attributes and
	// common container settings. Some fields are also present in
	// container.securityContext. Field values of
	// container.securityContext take precedence over field values of
	// PodSecurityContext.
	#: "io.k8s.api.core.v1.PodSecurityContext": {
		// appArmorProfile is the AppArmor options to use by the
		// containers in this pod. Note that this field cannot be set
		// when spec.os.name is windows.
		"appArmorProfile"?: #."io.k8s.api.core.v1.AppArmorProfile"

		// A special supplemental group that applies to all containers in
		// a pod. Some volume types allow the Kubelet to change the
		// ownership of that volume to be owned by the pod:
		//
		// 1. The owning GID will be the FSGroup 2. The setgid bit is set
		// (new files created in the volume will be owned by FSGroup) 3.
		// The permission bits are OR'd with rw-rw----
		//
		// If unset, the Kubelet will not modify the ownership and
		// permissions of any volume. Note that this field cannot be set
		// when spec.os.name is windows.
		"fsGroup"?: int

		// fsGroupChangePolicy defines behavior of changing ownership and
		// permission of the volume before being exposed inside Pod. This
		// field will only apply to volume types which support fsGroup
		// based ownership(and permissions). It will have no effect on
		// ephemeral volume types such as: secret, configmaps and
		// emptydir. Valid values are "OnRootMismatch" and "Always". If
		// not specified, "Always" is used. Note that this field cannot
		// be set when spec.os.name is windows.
		"fsGroupChangePolicy"?: string

		// The GID to run the entrypoint of the container process. Uses
		// runtime default if unset. May also be set in SecurityContext.
		// If set in both SecurityContext and PodSecurityContext, the
		// value specified in SecurityContext takes precedence for that
		// container. Note that this field cannot be set when
		// spec.os.name is windows.
		"runAsGroup"?: int

		// Indicates that the container must run as a non-root user. If
		// true, the Kubelet will validate the image at runtime to ensure
		// that it does not run as UID 0 (root) and fail to start the
		// container if it does. If unset or false, no such validation
		// will be performed. May also be set in SecurityContext. If set
		// in both SecurityContext and PodSecurityContext, the value
		// specified in SecurityContext takes precedence.
		"runAsNonRoot"?: bool

		// The UID to run the entrypoint of the container process.
		// Defaults to user specified in image metadata if unspecified.
		// May also be set in SecurityContext. If set in both
		// SecurityContext and PodSecurityContext, the value specified in
		// SecurityContext takes precedence for that container. Note that
		// this field cannot be set when spec.os.name is windows.
		"runAsUser"?: int

		// seLinuxChangePolicy defines how the container's SELinux label
		// is applied to all volumes used by the Pod. It has no effect on
		// nodes that do not support SELinux or to volumes does not
		// support SELinux. Valid values are "MountOption" and
		// "Recursive".
		//
		// "Recursive" means relabeling of all files on all Pod volumes by
		// the container runtime. This may be slow for large volumes, but
		// allows mixing privileged and unprivileged Pods sharing the
		// same volume on the same node.
		//
		// "MountOption" mounts all eligible Pod volumes with `-o context`
		// mount option. This requires all Pods that share the same
		// volume to use the same SELinux label. It is not possible to
		// share the same volume among privileged and unprivileged Pods.
		// Eligible volumes are in-tree FibreChannel and iSCSI volumes,
		// and all CSI volumes whose CSI driver announces SELinux support
		// by setting spec.seLinuxMount: true in their CSIDriver
		// instance. Other volumes are always re-labelled recursively.
		// "MountOption" value is allowed only when SELinuxMount feature
		// gate is enabled.
		//
		// If not specified and SELinuxMount feature gate is enabled,
		// "MountOption" is used. If not specified and SELinuxMount
		// feature gate is disabled, "MountOption" is used for
		// ReadWriteOncePod volumes and "Recursive" for all other
		// volumes.
		//
		// This field affects only Pods that have SELinux label set,
		// either in PodSecurityContext or in SecurityContext of all
		// containers.
		//
		// All Pods that use the same volume should use the same
		// seLinuxChangePolicy, otherwise some pods can get stuck in
		// ContainerCreating state. Note that this field cannot be set
		// when spec.os.name is windows.
		"seLinuxChangePolicy"?: string

		// The SELinux context to be applied to all containers. If
		// unspecified, the container runtime will allocate a random
		// SELinux context for each container. May also be set in
		// SecurityContext. If set in both SecurityContext and
		// PodSecurityContext, the value specified in SecurityContext
		// takes precedence for that container. Note that this field
		// cannot be set when spec.os.name is windows.
		"seLinuxOptions"?: #."io.k8s.api.core.v1.SELinuxOptions"

		// The seccomp options to use by the containers in this pod. Note
		// that this field cannot be set when spec.os.name is windows.
		"seccompProfile"?: #."io.k8s.api.core.v1.SeccompProfile"

		// A list of groups applied to the first process run in each
		// container, in addition to the container's primary GID and
		// fsGroup (if specified). If the SupplementalGroupsPolicy
		// feature is enabled, the supplementalGroupsPolicy field
		// determines whether these are in addition to or instead of any
		// group memberships defined in the container image. If
		// unspecified, no additional groups are added, though group
		// memberships defined in the container image may still be used,
		// depending on the supplementalGroupsPolicy field. Note that
		// this field cannot be set when spec.os.name is windows.
		"supplementalGroups"?: [...int]

		// Defines how supplemental groups of the first container
		// processes are calculated. Valid values are "Merge" and
		// "Strict". If not specified, "Merge" is used. (Alpha) Using the
		// field requires the SupplementalGroupsPolicy feature gate to be
		// enabled and the container runtime must implement support for
		// this feature. Note that this field cannot be set when
		// spec.os.name is windows.
		"supplementalGroupsPolicy"?: string

		// Sysctls hold a list of namespaced sysctls used for the pod.
		// Pods with unsupported sysctls (by the container runtime) might
		// fail to launch. Note that this field cannot be set when
		// spec.os.name is windows.
		"sysctls"?: [...#."io.k8s.api.core.v1.Sysctl"]

		// The Windows specific settings applied to all containers. If
		// unspecified, the options within a container's SecurityContext
		// will be used. If set in both SecurityContext and
		// PodSecurityContext, the value specified in SecurityContext
		// takes precedence. Note that this field cannot be set when
		// spec.os.name is linux.
		"windowsOptions"?: #."io.k8s.api.core.v1.WindowsSecurityContextOptions"
	}

	// PortworxVolumeSource represents a Portworx volume resource.
	#: "io.k8s.api.core.v1.PortworxVolumeSource": {
		// fSType represents the filesystem type to mount Must be a
		// filesystem type supported by the host operating system. Ex.
		// "ext4", "xfs". Implicitly inferred to be "ext4" if
		// unspecified.
		"fsType"?: string

		// readOnly defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// volumeID uniquely identifies a Portworx volume
		"volumeID"!: string
	}

	// An empty preferred scheduling term matches all objects with
	// implicit weight 0 (i.e. it's a no-op). A null preferred
	// scheduling term matches no objects (i.e. is also a no-op).
	#: "io.k8s.api.core.v1.PreferredSchedulingTerm": {
		// A node selector term, associated with the corresponding weight.
		"preference"!: #."io.k8s.api.core.v1.NodeSelectorTerm"

		// Weight associated with matching the corresponding
		// nodeSelectorTerm, in the range 1-100.
		"weight"!: int
	}

	// Probe describes a health check to be performed against a
	// container to determine whether it is alive or ready to receive
	// traffic.
	#: "io.k8s.api.core.v1.Probe": {
		// Exec specifies a command to execute in the container.
		"exec"?: #."io.k8s.api.core.v1.ExecAction"

		// Minimum consecutive failures for the probe to be considered
		// failed after having succeeded. Defaults to 3. Minimum value is
		// 1.
		"failureThreshold"?: int

		// GRPC specifies a GRPC HealthCheckRequest.
		"grpc"?: #."io.k8s.api.core.v1.GRPCAction"

		// HTTPGet specifies an HTTP GET request to perform.
		"httpGet"?: #."io.k8s.api.core.v1.HTTPGetAction"

		// Number of seconds after the container has started before
		// liveness probes are initiated. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"initialDelaySeconds"?: int

		// How often (in seconds) to perform the probe. Default to 10
		// seconds. Minimum value is 1.
		"periodSeconds"?: int

		// Minimum consecutive successes for the probe to be considered
		// successful after having failed. Defaults to 1. Must be 1 for
		// liveness and startup. Minimum value is 1.
		"successThreshold"?: int

		// TCPSocket specifies a connection to a TCP port.
		"tcpSocket"?: #."io.k8s.api.core.v1.TCPSocketAction"

		// Optional duration in seconds the pod needs to terminate
		// gracefully upon probe failure. The grace period is the
		// duration in seconds after the processes running in the pod are
		// sent a termination signal and the time when the processes are
		// forcibly halted with a kill signal. Set this value longer than
		// the expected cleanup time for your process. If this value is
		// nil, the pod's terminationGracePeriodSeconds will be used.
		// Otherwise, this value overrides the value provided by the pod
		// spec. Value must be non-negative integer. The value zero
		// indicates stop immediately via the kill signal (no opportunity
		// to shut down). This is a beta field and requires enabling
		// ProbeTerminationGracePeriod feature gate. Minimum value is 1.
		// spec.terminationGracePeriodSeconds is used if unset.
		"terminationGracePeriodSeconds"?: int

		// Number of seconds after which the probe times out. Defaults to
		// 1 second. Minimum value is 1. More info:
		// https://kubernetes.io/docs/concepts/workloads/pods/pod-lifecycle#container-probes
		"timeoutSeconds"?: int
	}

	// Represents a projected volume source
	#: "io.k8s.api.core.v1.ProjectedVolumeSource": {
		// defaultMode are the mode bits used to set permissions on
		// created files by default. Must be an octal value between 0000
		// and 0777 or a decimal value between 0 and 511. YAML accepts
		// both octal and decimal values, JSON requires decimal values
		// for mode bits. Directories within the path are not affected by
		// this setting. This might be in conflict with other options
		// that affect the file mode, like fsGroup, and the result can be
		// other mode bits set.
		"defaultMode"?: int

		// sources is the list of volume projections. Each entry in this
		// list handles one source.
		"sources"?: [...#."io.k8s.api.core.v1.VolumeProjection"]
	}

	// Represents a Quobyte mount that lasts the lifetime of a pod.
	// Quobyte volumes do not support ownership management or SELinux
	// relabeling.
	#: "io.k8s.api.core.v1.QuobyteVolumeSource": {
		// group to map volume access to Default is no group
		"group"?: string

		// readOnly here will force the Quobyte volume to be mounted with
		// read-only permissions. Defaults to false.
		"readOnly"?: bool

		// registry represents a single or multiple Quobyte Registry
		// services specified as a string as host:port pair (multiple
		// entries are separated with commas) which acts as the central
		// registry for volumes
		"registry"!: string

		// tenant owning the given Quobyte volume in the Backend Used with
		// dynamically provisioned Quobyte volumes, value is set by the
		// plugin
		"tenant"?: string

		// user to map volume access to Defaults to serivceaccount user
		"user"?: string

		// volume is a string that references an already created Quobyte
		// volume by name.
		"volume"!: string
	}

	// Represents a Rados Block Device mount that lasts the lifetime
	// of a pod. RBD volumes support ownership management and SELinux
	// relabeling.
	#: "io.k8s.api.core.v1.RBDVolumeSource": {
		// fsType is the filesystem type of the volume that you want to
		// mount. Tip: Ensure that the filesystem type is supported by
		// the host operating system. Examples: "ext4", "xfs", "ntfs".
		// Implicitly inferred to be "ext4" if unspecified. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#rbd
		"fsType"?: string

		// image is the rados image name. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"image"!: string

		// keyring is the path to key ring for RBDUser. Default is
		// /etc/ceph/keyring. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"keyring"?: string

		// monitors is a collection of Ceph monitors. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"monitors"!: [...string]

		// pool is the rados pool name. Default is rbd. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"pool"?: string

		// readOnly here will force the ReadOnly setting in VolumeMounts.
		// Defaults to false. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"readOnly"?: bool

		// secretRef is name of the authentication secret for RBDUser. If
		// provided overrides keyring. Default is nil. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// user is the rados user name. Default is admin. More info:
		// https://examples.k8s.io/volumes/rbd/README.md#how-to-use-it
		"user"?: string
	}

	// ResourceClaim references one entry in PodSpec.ResourceClaims.
	#: "io.k8s.api.core.v1.ResourceClaim": {
		// Name must match the name of one entry in
		// pod.spec.resourceClaims of the Pod where this field is used.
		// It makes that resource available inside a container.
		"name"!: string

		// Request is the name chosen for a request in the referenced
		// claim. If empty, everything from the claim is made available,
		// otherwise only the result of this request.
		"request"?: string
	}

	// ResourceFieldSelector represents container resources (cpu,
	// memory) and their output format
	#: "io.k8s.api.core.v1.ResourceFieldSelector": {
		// Container name: required for volumes, optional for env vars
		"containerName"?: string

		// Specifies the output format of the exposed resources, defaults
		// to "1"
		"divisor"?: #."io.k8s.apimachinery.pkg.api.resource.Quantity"

		// Required: resource to select
		"resource"!: string
	}

	// ResourceRequirements describes the compute resource
	// requirements.
	#: "io.k8s.api.core.v1.ResourceRequirements": {
		// Claims lists the names of resources, defined in
		// spec.resourceClaims, that are used by this container.
		//
		// This is an alpha field and requires enabling the
		// DynamicResourceAllocation feature gate.
		//
		// This field is immutable. It can only be set for containers.
		"claims"?: [...#."io.k8s.api.core.v1.ResourceClaim"]

		// Limits describes the maximum amount of compute resources
		// allowed. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"limits"?: {
			[string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
		}

		// Requests describes the minimum amount of compute resources
		// required. If Requests is omitted for a container, it defaults
		// to Limits if that is explicitly specified, otherwise to an
		// implementation-defined value. Requests cannot exceed Limits.
		// More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"requests"?: {
			[string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
		}
	}

	// SELinuxOptions are the labels to be applied to the container
	#: "io.k8s.api.core.v1.SELinuxOptions": {
		// Level is SELinux level label that applies to the container.
		"level"?: string

		// Role is a SELinux role label that applies to the container.
		"role"?: string

		// Type is a SELinux type label that applies to the container.
		"type"?: string

		// User is a SELinux user label that applies to the container.
		"user"?: string
	}

	// ScaleIOVolumeSource represents a persistent ScaleIO volume
	#: "io.k8s.api.core.v1.ScaleIOVolumeSource": {
		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Ex. "ext4",
		// "xfs", "ntfs". Default is "xfs".
		"fsType"?: string

		// gateway is the host address of the ScaleIO API Gateway.
		"gateway"!: string

		// protectionDomain is the name of the ScaleIO Protection Domain
		// for the configured storage.
		"protectionDomain"?: string

		// readOnly Defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// secretRef references to the secret for ScaleIO user and other
		// sensitive information. If this is not provided, Login
		// operation will fail.
		"secretRef"!: #."io.k8s.api.core.v1.LocalObjectReference"

		// sslEnabled Flag enable/disable SSL communication with Gateway,
		// default false
		"sslEnabled"?: bool

		// storageMode indicates whether the storage for a volume should
		// be ThickProvisioned or ThinProvisioned. Default is
		// ThinProvisioned.
		"storageMode"?: string

		// storagePool is the ScaleIO Storage Pool associated with the
		// protection domain.
		"storagePool"?: string

		// system is the name of the storage system as configured in
		// ScaleIO.
		"system"!: string

		// volumeName is the name of a volume already created in the
		// ScaleIO system that is associated with this volume source.
		"volumeName"?: string
	}

	// SeccompProfile defines a pod/container's seccomp profile
	// settings. Only one profile source may be set.
	#: "io.k8s.api.core.v1.SeccompProfile": {
		// localhostProfile indicates a profile defined in a file on the
		// node should be used. The profile must be preconfigured on the
		// node to work. Must be a descending path, relative to the
		// kubelet's configured seccomp profile location. Must be set if
		// type is "Localhost". Must NOT be set for any other type.
		"localhostProfile"?: string

		// type indicates which kind of seccomp profile will be applied.
		// Valid options are:
		//
		// Localhost - a profile defined in a file on the node should be
		// used. RuntimeDefault - the container runtime default profile
		// should be used. Unconfined - no profile should be applied.
		"type"!: string
	}

	// SecretEnvSource selects a Secret to populate the environment
	// variables with.
	//
	// The contents of the target Secret's Data field will represent
	// the key-value pairs as environment variables.
	#: "io.k8s.api.core.v1.SecretEnvSource": {
		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// Specify whether the Secret must be defined
		"optional"?: bool
	}

	// SecretKeySelector selects a key of a Secret.
	#: "io.k8s.api.core.v1.SecretKeySelector": {
		// The key of the secret to select from. Must be a valid secret
		// key.
		"key"!: string

		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// Specify whether the Secret or its key must be defined
		"optional"?: bool
	}

	// Adapts a secret into a projected volume.
	//
	// The contents of the target Secret's Data field will be
	// presented in a projected volume as files using the keys in the
	// Data field as the file names. Note that this is identical to a
	// secret volume source without the default mode.
	#: "io.k8s.api.core.v1.SecretProjection": {
		// items if unspecified, each key-value pair in the Data field of
		// the referenced Secret will be projected into the volume as a
		// file whose name is the key and content is the value. If
		// specified, the listed keys will be projected into the
		// specified paths, and unlisted keys will not be present. If a
		// key is specified which is not present in the Secret, the
		// volume setup will error unless it is marked optional. Paths
		// must be relative and may not contain the '..' path or start
		// with '..'.
		"items"?: [...#."io.k8s.api.core.v1.KeyToPath"]

		// Name of the referent. This field is effectively required, but
		// due to backwards compatibility is allowed to be empty.
		// Instances of this type with an empty value here are almost
		// certainly wrong. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"?: string

		// optional field specify whether the Secret or its key must be
		// defined
		"optional"?: bool
	}

	// Adapts a Secret into a volume.
	//
	// The contents of the target Secret's Data field will be
	// presented in a volume as files using the keys in the Data
	// field as the file names. Secret volumes support ownership
	// management and SELinux relabeling.
	#: "io.k8s.api.core.v1.SecretVolumeSource": {
		// defaultMode is Optional: mode bits used to set permissions on
		// created files by default. Must be an octal value between 0000
		// and 0777 or a decimal value between 0 and 511. YAML accepts
		// both octal and decimal values, JSON requires decimal values
		// for mode bits. Defaults to 0644. Directories within the path
		// are not affected by this setting. This might be in conflict
		// with other options that affect the file mode, like fsGroup,
		// and the result can be other mode bits set.
		"defaultMode"?: int

		// items If unspecified, each key-value pair in the Data field of
		// the referenced Secret will be projected into the volume as a
		// file whose name is the key and content is the value. If
		// specified, the listed keys will be projected into the
		// specified paths, and unlisted keys will not be present. If a
		// key is specified which is not present in the Secret, the
		// volume setup will error unless it is marked optional. Paths
		// must be relative and may not contain the '..' path or start
		// with '..'.
		"items"?: [...#."io.k8s.api.core.v1.KeyToPath"]

		// optional field specify whether the Secret or its keys must be
		// defined
		"optional"?: bool

		// secretName is the name of the secret in the pod's namespace to
		// use. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#secret
		"secretName"?: string
	}

	// SecurityContext holds security configuration that will be
	// applied to a container. Some fields are present in both
	// SecurityContext and PodSecurityContext. When both are set, the
	// values in SecurityContext take precedence.
	#: "io.k8s.api.core.v1.SecurityContext": {
		// AllowPrivilegeEscalation controls whether a process can gain
		// more privileges than its parent process. This bool directly
		// controls if the no_new_privs flag will be set on the container
		// process. AllowPrivilegeEscalation is true always when the
		// container is: 1) run as Privileged 2) has CAP_SYS_ADMIN Note
		// that this field cannot be set when spec.os.name is windows.
		"allowPrivilegeEscalation"?: bool

		// appArmorProfile is the AppArmor options to use by this
		// container. If set, this profile overrides the pod's
		// appArmorProfile. Note that this field cannot be set when
		// spec.os.name is windows.
		"appArmorProfile"?: #."io.k8s.api.core.v1.AppArmorProfile"

		// The capabilities to add/drop when running containers. Defaults
		// to the default set of capabilities granted by the container
		// runtime. Note that this field cannot be set when spec.os.name
		// is windows.
		"capabilities"?: #."io.k8s.api.core.v1.Capabilities"

		// Run container in privileged mode. Processes in privileged
		// containers are essentially equivalent to root on the host.
		// Defaults to false. Note that this field cannot be set when
		// spec.os.name is windows.
		"privileged"?: bool

		// procMount denotes the type of proc mount to use for the
		// containers. The default value is Default which uses the
		// container runtime defaults for readonly paths and masked
		// paths. This requires the ProcMountType feature flag to be
		// enabled. Note that this field cannot be set when spec.os.name
		// is windows.
		"procMount"?: string

		// Whether this container has a read-only root filesystem. Default
		// is false. Note that this field cannot be set when spec.os.name
		// is windows.
		"readOnlyRootFilesystem"?: bool

		// The GID to run the entrypoint of the container process. Uses
		// runtime default if unset. May also be set in
		// PodSecurityContext. If set in both SecurityContext and
		// PodSecurityContext, the value specified in SecurityContext
		// takes precedence. Note that this field cannot be set when
		// spec.os.name is windows.
		"runAsGroup"?: int

		// Indicates that the container must run as a non-root user. If
		// true, the Kubelet will validate the image at runtime to ensure
		// that it does not run as UID 0 (root) and fail to start the
		// container if it does. If unset or false, no such validation
		// will be performed. May also be set in PodSecurityContext. If
		// set in both SecurityContext and PodSecurityContext, the value
		// specified in SecurityContext takes precedence.
		"runAsNonRoot"?: bool

		// The UID to run the entrypoint of the container process.
		// Defaults to user specified in image metadata if unspecified.
		// May also be set in PodSecurityContext. If set in both
		// SecurityContext and PodSecurityContext, the value specified in
		// SecurityContext takes precedence. Note that this field cannot
		// be set when spec.os.name is windows.
		"runAsUser"?: int

		// The SELinux context to be applied to the container. If
		// unspecified, the container runtime will allocate a random
		// SELinux context for each container. May also be set in
		// PodSecurityContext. If set in both SecurityContext and
		// PodSecurityContext, the value specified in SecurityContext
		// takes precedence. Note that this field cannot be set when
		// spec.os.name is windows.
		"seLinuxOptions"?: #."io.k8s.api.core.v1.SELinuxOptions"

		// The seccomp options to use by this container. If seccomp
		// options are provided at both the pod & container level, the
		// container options override the pod options. Note that this
		// field cannot be set when spec.os.name is windows.
		"seccompProfile"?: #."io.k8s.api.core.v1.SeccompProfile"

		// The Windows specific settings applied to all containers. If
		// unspecified, the options from the PodSecurityContext will be
		// used. If set in both SecurityContext and PodSecurityContext,
		// the value specified in SecurityContext takes precedence. Note
		// that this field cannot be set when spec.os.name is linux.
		"windowsOptions"?: #."io.k8s.api.core.v1.WindowsSecurityContextOptions"
	}

	// ServiceAccountTokenProjection represents a projected service
	// account token volume. This projection can be used to insert a
	// service account token into the pods runtime filesystem for use
	// against APIs (Kubernetes API Server or otherwise).
	#: "io.k8s.api.core.v1.ServiceAccountTokenProjection": {
		// audience is the intended audience of the token. A recipient of
		// a token must identify itself with an identifier specified in
		// the audience of the token, and otherwise should reject the
		// token. The audience defaults to the identifier of the
		// apiserver.
		"audience"?: string

		// expirationSeconds is the requested duration of validity of the
		// service account token. As the token approaches expiration, the
		// kubelet volume plugin will proactively rotate the service
		// account token. The kubelet will start trying to rotate the
		// token if the token is older than 80 percent of its time to
		// live or if the token is older than 24 hours.Defaults to 1 hour
		// and must be at least 10 minutes.
		"expirationSeconds"?: int

		// path is the path relative to the mount point of the file to
		// project the token into.
		"path"!: string
	}

	// ServicePort contains information on service's port.
	#: "io.k8s.api.core.v1.ServicePort": {
		// The application protocol for this port. This is used as a hint
		// for implementations to offer richer behavior for protocols
		// that they understand. This field follows standard Kubernetes
		// label syntax. Valid values are either:
		//
		// * Un-prefixed protocol names - reserved for IANA standard
		// service names (as per RFC-6335 and
		// https://www.iana.org/assignments/service-names).
		//
		// * Kubernetes-defined prefixed names:
		// * 'kubernetes.io/h2c' - HTTP/2 prior knowledge over cleartext
		// as described in
		// https://www.rfc-editor.org/rfc/rfc9113.html#name-starting-http-2-with-prior-
		// * 'kubernetes.io/ws' - WebSocket over cleartext as described in
		// https://www.rfc-editor.org/rfc/rfc6455
		// * 'kubernetes.io/wss' - WebSocket over TLS as described in
		// https://www.rfc-editor.org/rfc/rfc6455
		//
		// * Other protocols should use implementation-defined prefixed
		// names such as mycompany.com/my-custom-protocol.
		"appProtocol"?: string

		// The name of this port within the service. This must be a
		// DNS_LABEL. All ports within a ServiceSpec must have unique
		// names. When considering the endpoints for a Service, this must
		// match the 'name' field in the EndpointPort. Optional if only
		// one ServicePort is defined on this service.
		"name"?: string

		// The port on each node on which this service is exposed when
		// type is NodePort or LoadBalancer. Usually assigned by the
		// system. If a value is specified, in-range, and not in use it
		// will be used, otherwise the operation will fail. If not
		// specified, a port will be allocated if this Service requires
		// one. If this field is specified when creating a Service which
		// does not need it, creation will fail. This field will be wiped
		// when updating a Service to no longer need it (e.g. changing
		// type from NodePort to ClusterIP). More info:
		// https://kubernetes.io/docs/concepts/services-networking/service/#type-nodeport
		"nodePort"?: int

		// The port that will be exposed by this service.
		"port"!: int

		// The IP protocol for this port. Supports "TCP", "UDP", and
		// "SCTP". Default is TCP.
		"protocol"?: string

		// Number or name of the port to access on the pods targeted by
		// the service. Number must be in the range 1 to 65535. Name must
		// be an IANA_SVC_NAME. If this is a string, it will be looked up
		// as a named port in the target Pod's container ports. If this
		// is not specified, the value of the 'port' field is used (an
		// identity map). This field is ignored for services with
		// clusterIP=None, and should be omitted or set equal to the
		// 'port' field. More info:
		// https://kubernetes.io/docs/concepts/services-networking/service/#defining-a-service
		"targetPort"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"
	}

	// SleepAction describes a "sleep" action.
	#: "io.k8s.api.core.v1.SleepAction": {
		// Seconds is the number of seconds to sleep.
		"seconds"!: int
	}

	// Represents a StorageOS persistent volume resource.
	#: "io.k8s.api.core.v1.StorageOSVolumeSource": {
		// fsType is the filesystem type to mount. Must be a filesystem
		// type supported by the host operating system. Ex. "ext4",
		// "xfs", "ntfs". Implicitly inferred to be "ext4" if
		// unspecified.
		"fsType"?: string

		// readOnly defaults to false (read/write). ReadOnly here will
		// force the ReadOnly setting in VolumeMounts.
		"readOnly"?: bool

		// secretRef specifies the secret to use for obtaining the
		// StorageOS API credentials. If not specified, default values
		// will be attempted.
		"secretRef"?: #."io.k8s.api.core.v1.LocalObjectReference"

		// volumeName is the human-readable name of the StorageOS volume.
		// Volume names are only unique within a namespace.
		"volumeName"?: string

		// volumeNamespace specifies the scope of the volume within
		// StorageOS. If no namespace is specified then the Pod's
		// namespace will be used. This allows the Kubernetes name
		// scoping to be mirrored within StorageOS for tighter
		// integration. Set VolumeName to any name to override the
		// default behaviour. Set to "default" if you are not using
		// namespaces within StorageOS. Namespaces that do not pre-exist
		// within StorageOS will be created.
		"volumeNamespace"?: string
	}

	// Sysctl defines a kernel parameter to be set
	#: "io.k8s.api.core.v1.Sysctl": {
		// Name of a property to set
		"name"!: string

		// Value of a property to set
		"value"!: string
	}

	// TCPSocketAction describes an action based on opening a socket
	#: "io.k8s.api.core.v1.TCPSocketAction": {
		// Optional: Host name to connect to, defaults to the pod IP.
		"host"?: string

		// Number or name of the port to access on the container. Number
		// must be in the range 1 to 65535. Name must be an
		// IANA_SVC_NAME.
		"port"!: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"
	}

	// The pod this Toleration is attached to tolerates any taint that
	// matches the triple <key,value,effect> using the matching
	// operator <operator>.
	#: "io.k8s.api.core.v1.Toleration": {
		// Effect indicates the taint effect to match. Empty means match
		// all taint effects. When specified, allowed values are
		// NoSchedule, PreferNoSchedule and NoExecute.
		"effect"?: string

		// Key is the taint key that the toleration applies to. Empty
		// means match all taint keys. If the key is empty, operator must
		// be Exists; this combination means to match all values and all
		// keys.
		"key"?: string

		// Operator represents a key's relationship to the value. Valid
		// operators are Exists and Equal. Defaults to Equal. Exists is
		// equivalent to wildcard for value, so that a pod can tolerate
		// all taints of a particular category.
		"operator"?: string

		// TolerationSeconds represents the period of time the toleration
		// (which must be of effect NoExecute, otherwise this field is
		// ignored) tolerates the taint. By default, it is not set, which
		// means tolerate the taint forever (do not evict). Zero and
		// negative values will be treated as 0 (evict immediately) by
		// the system.
		"tolerationSeconds"?: int

		// Value is the taint value the toleration matches to. If the
		// operator is Exists, the value should be empty, otherwise just
		// a regular string.
		"value"?: string
	}

	// TypedLocalObjectReference contains enough information to let
	// you locate the typed referenced object inside the same
	// namespace.
	#: "io.k8s.api.core.v1.TypedLocalObjectReference": {
		// APIGroup is the group for the resource being referenced. If
		// APIGroup is not specified, the specified Kind must be in the
		// core API group. For any other third-party types, APIGroup is
		// required.
		"apiGroup"?: string

		// Kind is the type of resource being referenced
		"kind"!: string

		// Name is the name of resource being referenced
		"name"!: string
	}

	// TypedObjectReference contains enough information to let you
	// locate the typed referenced object
	#: "io.k8s.api.core.v1.TypedObjectReference": {
		// APIGroup is the group for the resource being referenced. If
		// APIGroup is not specified, the specified Kind must be in the
		// core API group. For any other third-party types, APIGroup is
		// required.
		"apiGroup"?: string

		// Kind is the type of resource being referenced
		"kind"!: string

		// Name is the name of resource being referenced
		"name"!: string

		// Namespace is the namespace of resource being referenced Note
		// that when a namespace is specified, a
		// gateway.networking.k8s.io/ReferenceGrant object is required in
		// the referent namespace to allow that namespace's owner to
		// accept the reference. See the ReferenceGrant documentation for
		// details. (Alpha) This field requires the
		// CrossNamespaceVolumeDataSource feature gate to be enabled.
		"namespace"?: string
	}

	// Volume represents a named volume in a pod that may be accessed
	// by any container in the pod.
	#: "io.k8s.api.core.v1.Volume": {
		// awsElasticBlockStore represents an AWS Disk resource that is
		// attached to a kubelet's host machine and then exposed to the
		// pod. Deprecated: AWSElasticBlockStore is deprecated. All
		// operations for the in-tree awsElasticBlockStore type are
		// redirected to the ebs.csi.aws.com CSI driver. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#awselasticblockstore
		"awsElasticBlockStore"?: #."io.k8s.api.core.v1.AWSElasticBlockStoreVolumeSource"

		// azureDisk represents an Azure Data Disk mount on the host and
		// bind mount to the pod. Deprecated: AzureDisk is deprecated.
		// All operations for the in-tree azureDisk type are redirected
		// to the disk.csi.azure.com CSI driver.
		"azureDisk"?: #."io.k8s.api.core.v1.AzureDiskVolumeSource"

		// azureFile represents an Azure File Service mount on the host
		// and bind mount to the pod. Deprecated: AzureFile is
		// deprecated. All operations for the in-tree azureFile type are
		// redirected to the file.csi.azure.com CSI driver.
		"azureFile"?: #."io.k8s.api.core.v1.AzureFileVolumeSource"

		// cephFS represents a Ceph FS mount on the host that shares a
		// pod's lifetime. Deprecated: CephFS is deprecated and the
		// in-tree cephfs type is no longer supported.
		"cephfs"?: #."io.k8s.api.core.v1.CephFSVolumeSource"

		// cinder represents a cinder volume attached and mounted on
		// kubelets host machine. Deprecated: Cinder is deprecated. All
		// operations for the in-tree cinder type are redirected to the
		// cinder.csi.openstack.org CSI driver. More info:
		// https://examples.k8s.io/mysql-cinder-pd/README.md
		"cinder"?: #."io.k8s.api.core.v1.CinderVolumeSource"

		// configMap represents a configMap that should populate this
		// volume
		"configMap"?: #."io.k8s.api.core.v1.ConfigMapVolumeSource"

		// csi (Container Storage Interface) represents ephemeral storage
		// that is handled by certain external CSI drivers.
		"csi"?: #."io.k8s.api.core.v1.CSIVolumeSource"

		// downwardAPI represents downward API about the pod that should
		// populate this volume
		"downwardAPI"?: #."io.k8s.api.core.v1.DownwardAPIVolumeSource"

		// emptyDir represents a temporary directory that shares a pod's
		// lifetime. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#emptydir
		"emptyDir"?: #."io.k8s.api.core.v1.EmptyDirVolumeSource"

		// ephemeral represents a volume that is handled by a cluster
		// storage driver. The volume's lifecycle is tied to the pod that
		// defines it - it will be created before the pod starts, and
		// deleted when the pod is removed.
		//
		// Use this if: a) the volume is only needed while the pod runs,
		// b) features of normal volumes like restoring from snapshot or
		// capacity
		// tracking are needed,
		// c) the storage driver is specified through a storage class, and
		// d) the storage driver supports dynamic volume provisioning
		// through
		// a PersistentVolumeClaim (see EphemeralVolumeSource for more
		// information on the connection between this volume type
		// and PersistentVolumeClaim).
		//
		// Use PersistentVolumeClaim or one of the vendor-specific APIs
		// for volumes that persist for longer than the lifecycle of an
		// individual pod.
		//
		// Use CSI for light-weight local ephemeral volumes if the CSI
		// driver is meant to be used that way - see the documentation of
		// the driver for more information.
		//
		// A pod can use both types of ephemeral volumes and persistent
		// volumes at the same time.
		"ephemeral"?: #."io.k8s.api.core.v1.EphemeralVolumeSource"

		// fc represents a Fibre Channel resource that is attached to a
		// kubelet's host machine and then exposed to the pod.
		"fc"?: #."io.k8s.api.core.v1.FCVolumeSource"

		// flexVolume represents a generic volume resource that is
		// provisioned/attached using an exec based plugin. Deprecated:
		// FlexVolume is deprecated. Consider using a CSIDriver instead.
		"flexVolume"?: #."io.k8s.api.core.v1.FlexVolumeSource"

		// flocker represents a Flocker volume attached to a kubelet's
		// host machine. This depends on the Flocker control service
		// being running. Deprecated: Flocker is deprecated and the
		// in-tree flocker type is no longer supported.
		"flocker"?: #."io.k8s.api.core.v1.FlockerVolumeSource"

		// gcePersistentDisk represents a GCE Disk resource that is
		// attached to a kubelet's host machine and then exposed to the
		// pod. Deprecated: GCEPersistentDisk is deprecated. All
		// operations for the in-tree gcePersistentDisk type are
		// redirected to the pd.csi.storage.gke.io CSI driver. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#gcepersistentdisk
		"gcePersistentDisk"?: #."io.k8s.api.core.v1.GCEPersistentDiskVolumeSource"

		// gitRepo represents a git repository at a particular revision.
		// Deprecated: GitRepo is deprecated. To provision a container
		// with a git repo, mount an EmptyDir into an InitContainer that
		// clones the repo using git, then mount the EmptyDir into the
		// Pod's container.
		"gitRepo"?: #."io.k8s.api.core.v1.GitRepoVolumeSource"

		// glusterfs represents a Glusterfs mount on the host that shares
		// a pod's lifetime. Deprecated: Glusterfs is deprecated and the
		// in-tree glusterfs type is no longer supported. More info:
		// https://examples.k8s.io/volumes/glusterfs/README.md
		"glusterfs"?: #."io.k8s.api.core.v1.GlusterfsVolumeSource"

		// hostPath represents a pre-existing file or directory on the
		// host machine that is directly exposed to the container. This
		// is generally used for system agents or other privileged things
		// that are allowed to see the host machine. Most containers will
		// NOT need this. More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#hostpath
		"hostPath"?: #."io.k8s.api.core.v1.HostPathVolumeSource"

		// image represents an OCI object (a container image or artifact)
		// pulled and mounted on the kubelet's host machine. The volume
		// is resolved at pod startup depending on which PullPolicy value
		// is provided:
		//
		// - Always: the kubelet always attempts to pull the reference.
		// Container creation will fail If the pull fails. - Never: the
		// kubelet never pulls the reference and only uses a local image
		// or artifact. Container creation will fail if the reference
		// isn't present. - IfNotPresent: the kubelet pulls if the
		// reference isn't already present on disk. Container creation
		// will fail if the reference isn't present and the pull fails.
		//
		// The volume gets re-resolved if the pod gets deleted and
		// recreated, which means that new remote content will become
		// available on pod recreation. A failure to resolve or pull the
		// image during pod startup will block containers from starting
		// and may add significant latency. Failures will be retried
		// using normal volume backoff and will be reported on the pod
		// reason and message. The types of objects that may be mounted
		// by this volume are defined by the container runtime
		// implementation on a host machine and at minimum must include
		// all valid types supported by the container image field. The
		// OCI object gets mounted in a single directory
		// (spec.containers[*].volumeMounts.mountPath) by merging the
		// manifest layers in the same way as for container images. The
		// volume will be mounted read-only (ro) and non-executable files
		// (noexec). Sub path mounts for containers are not supported
		// (spec.containers[*].volumeMounts.subpath) before 1.33. The
		// field spec.securityContext.fsGroupChangePolicy has no effect
		// on this volume type.
		"image"?: #."io.k8s.api.core.v1.ImageVolumeSource"

		// iscsi represents an ISCSI Disk resource that is attached to a
		// kubelet's host machine and then exposed to the pod. More info:
		// https://examples.k8s.io/volumes/iscsi/README.md
		"iscsi"?: #."io.k8s.api.core.v1.ISCSIVolumeSource"

		// name of the volume. Must be a DNS_LABEL and unique within the
		// pod. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names/#names
		"name"!: string

		// nfs represents an NFS mount on the host that shares a pod's
		// lifetime More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#nfs
		"nfs"?: #."io.k8s.api.core.v1.NFSVolumeSource"

		// persistentVolumeClaimVolumeSource represents a reference to a
		// PersistentVolumeClaim in the same namespace. More info:
		// https://kubernetes.io/docs/concepts/storage/persistent-volumes#persistentvolumeclaims
		"persistentVolumeClaim"?: #."io.k8s.api.core.v1.PersistentVolumeClaimVolumeSource"

		// photonPersistentDisk represents a PhotonController persistent
		// disk attached and mounted on kubelets host machine.
		// Deprecated: PhotonPersistentDisk is deprecated and the in-tree
		// photonPersistentDisk type is no longer supported.
		"photonPersistentDisk"?: #."io.k8s.api.core.v1.PhotonPersistentDiskVolumeSource"

		// portworxVolume represents a portworx volume attached and
		// mounted on kubelets host machine. Deprecated: PortworxVolume
		// is deprecated. All operations for the in-tree portworxVolume
		// type are redirected to the pxd.portworx.com CSI driver when
		// the CSIMigrationPortworx feature-gate is on.
		"portworxVolume"?: #."io.k8s.api.core.v1.PortworxVolumeSource"

		// projected items for all in one resources secrets, configmaps,
		// and downward API
		"projected"?: #."io.k8s.api.core.v1.ProjectedVolumeSource"

		// quobyte represents a Quobyte mount on the host that shares a
		// pod's lifetime. Deprecated: Quobyte is deprecated and the
		// in-tree quobyte type is no longer supported.
		"quobyte"?: #."io.k8s.api.core.v1.QuobyteVolumeSource"

		// rbd represents a Rados Block Device mount on the host that
		// shares a pod's lifetime. Deprecated: RBD is deprecated and the
		// in-tree rbd type is no longer supported. More info:
		// https://examples.k8s.io/volumes/rbd/README.md
		"rbd"?: #."io.k8s.api.core.v1.RBDVolumeSource"

		// scaleIO represents a ScaleIO persistent volume attached and
		// mounted on Kubernetes nodes. Deprecated: ScaleIO is deprecated
		// and the in-tree scaleIO type is no longer supported.
		"scaleIO"?: #."io.k8s.api.core.v1.ScaleIOVolumeSource"

		// secret represents a secret that should populate this volume.
		// More info:
		// https://kubernetes.io/docs/concepts/storage/volumes#secret
		"secret"?: #."io.k8s.api.core.v1.SecretVolumeSource"

		// storageOS represents a StorageOS volume attached and mounted on
		// Kubernetes nodes. Deprecated: StorageOS is deprecated and the
		// in-tree storageos type is no longer supported.
		"storageos"?: #."io.k8s.api.core.v1.StorageOSVolumeSource"

		// vsphereVolume represents a vSphere volume attached and mounted
		// on kubelets host machine. Deprecated: VsphereVolume is
		// deprecated. All operations for the in-tree vsphereVolume type
		// are redirected to the csi.vsphere.vmware.com CSI driver.
		"vsphereVolume"?: #."io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource"
	}

	// volumeDevice describes a mapping of a raw block device within a
	// container.
	#: "io.k8s.api.core.v1.VolumeDevice": {
		// devicePath is the path inside of the container that the device
		// will be mapped to.
		"devicePath"!: string

		// name must match the name of a persistentVolumeClaim in the pod
		"name"!: string
	}

	// VolumeMount describes a mounting of a Volume within a
	// container.
	#: "io.k8s.api.core.v1.VolumeMount": {
		// Path within the container at which the volume should be
		// mounted. Must not contain ':'.
		"mountPath"!: string

		// mountPropagation determines how mounts are propagated from the
		// host to container and the other way around. When not set,
		// MountPropagationNone is used. This field is beta in 1.10. When
		// RecursiveReadOnly is set to IfPossible or to Enabled,
		// MountPropagation must be None or unspecified (which defaults
		// to None).
		"mountPropagation"?: string

		// This must match the Name of a Volume.
		"name"!: string

		// Mounted read-only if true, read-write otherwise (false or
		// unspecified). Defaults to false.
		"readOnly"?: bool

		// RecursiveReadOnly specifies whether read-only mounts should be
		// handled recursively.
		//
		// If ReadOnly is false, this field has no meaning and must be
		// unspecified.
		//
		// If ReadOnly is true, and this field is set to Disabled, the
		// mount is not made recursively read-only. If this field is set
		// to IfPossible, the mount is made recursively read-only, if it
		// is supported by the container runtime. If this field is set to
		// Enabled, the mount is made recursively read-only if it is
		// supported by the container runtime, otherwise the pod will not
		// be started and an error will be generated to indicate the
		// reason.
		//
		// If this field is set to IfPossible or Enabled, MountPropagation
		// must be set to None (or be unspecified, which defaults to
		// None).
		//
		// If this field is not specified, it is treated as an equivalent
		// of Disabled.
		"recursiveReadOnly"?: string

		// Path within the volume from which the container's volume should
		// be mounted. Defaults to "" (volume's root).
		"subPath"?: string

		// Expanded path within the volume from which the container's
		// volume should be mounted. Behaves similarly to SubPath but
		// environment variable references $(VAR_NAME) are expanded using
		// the container's environment. Defaults to "" (volume's root).
		// SubPathExpr and SubPath are mutually exclusive.
		"subPathExpr"?: string
	}

	// Projection that may be projected along with other supported
	// volume types. Exactly one of these fields must be set.
	#: "io.k8s.api.core.v1.VolumeProjection": {
		// ClusterTrustBundle allows a pod to access the
		// `.spec.trustBundle` field of ClusterTrustBundle objects in an
		// auto-updating file.
		//
		// Alpha, gated by the ClusterTrustBundleProjection feature gate.
		//
		// ClusterTrustBundle objects can either be selected by name, or
		// by the combination of signer name and a label selector.
		//
		// Kubelet performs aggressive normalization of the PEM contents
		// written into the pod filesystem. Esoteric PEM features such as
		// inter-block comments and block headers are stripped.
		// Certificates are deduplicated. The ordering of certificates
		// within the file is arbitrary, and Kubelet may change the order
		// over time.
		"clusterTrustBundle"?: #."io.k8s.api.core.v1.ClusterTrustBundleProjection"

		// configMap information about the configMap data to project
		"configMap"?: #."io.k8s.api.core.v1.ConfigMapProjection"

		// downwardAPI information about the downwardAPI data to project
		"downwardAPI"?: #."io.k8s.api.core.v1.DownwardAPIProjection"

		// secret information about the secret data to project
		"secret"?: #."io.k8s.api.core.v1.SecretProjection"

		// serviceAccountToken is information about the
		// serviceAccountToken data to project
		"serviceAccountToken"?: #."io.k8s.api.core.v1.ServiceAccountTokenProjection"
	}

	// VolumeResourceRequirements describes the storage resource
	// requirements for a volume.
	#: "io.k8s.api.core.v1.VolumeResourceRequirements": {
		// Limits describes the maximum amount of compute resources
		// allowed. More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"limits"?: [string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"

		// Requests describes the minimum amount of compute resources
		// required. If Requests is omitted for a container, it defaults
		// to Limits if that is explicitly specified, otherwise to an
		// implementation-defined value. Requests cannot exceed Limits.
		// More info:
		// https://kubernetes.io/docs/concepts/configuration/manage-resources-containers/
		"requests"?: {
			[string]: #."io.k8s.apimachinery.pkg.api.resource.Quantity"
		}
	}

	// Represents a vSphere volume resource.
	#: "io.k8s.api.core.v1.VsphereVirtualDiskVolumeSource": {
		// fsType is filesystem type to mount. Must be a filesystem type
		// supported by the host operating system. Ex. "ext4", "xfs",
		// "ntfs". Implicitly inferred to be "ext4" if unspecified.
		"fsType"?: string

		// storagePolicyID is the storage Policy Based Management (SPBM)
		// profile ID associated with the StoragePolicyName.
		"storagePolicyID"?: string

		// storagePolicyName is the storage Policy Based Management (SPBM)
		// profile name.
		"storagePolicyName"?: string

		// volumePath is the path that identifies vSphere volume vmdk
		"volumePath"!: string
	}

	// The weights of all of the matched WeightedPodAffinityTerm
	// fields are added per-node to find the most preferred node(s)
	#: "io.k8s.api.core.v1.WeightedPodAffinityTerm": {
		// Required. A pod affinity term, associated with the
		// corresponding weight.
		"podAffinityTerm"!: #."io.k8s.api.core.v1.PodAffinityTerm"

		// weight associated with matching the corresponding
		// podAffinityTerm, in the range 1-100.
		"weight"!: int
	}

	// WindowsSecurityContextOptions contain Windows-specific options
	// and credentials.
	#: "io.k8s.api.core.v1.WindowsSecurityContextOptions": {
		// GMSACredentialSpec is where the GMSA admission webhook
		// (https://github.com/kubernetes-sigs/windows-gmsa) inlines the
		// contents of the GMSA credential spec named by the
		// GMSACredentialSpecName field.
		"gmsaCredentialSpec"?: string

		// GMSACredentialSpecName is the name of the GMSA credential spec
		// to use.
		"gmsaCredentialSpecName"?: string

		// HostProcess determines if a container should be run as a 'Host
		// Process' container. All of a Pod's containers must have the
		// same effective HostProcess value (it is not allowed to have a
		// mix of HostProcess containers and non-HostProcess containers).
		// In addition, if HostProcess is true then HostNetwork must also
		// be set to true.
		"hostProcess"?: bool

		// The UserName in Windows to run the entrypoint of the container
		// process. Defaults to the user specified in image metadata if
		// unspecified. May also be set in PodSecurityContext. If set in
		// both SecurityContext and PodSecurityContext, the value
		// specified in SecurityContext takes precedence.
		"runAsUserName"?: string
	}

	// PodDisruptionBudgetSpec is a description of a
	// PodDisruptionBudget.
	#: "io.k8s.api.policy.v1.PodDisruptionBudgetSpec": {
		// An eviction is allowed if at most "maxUnavailable" pods
		// selected by "selector" are unavailable after the eviction,
		// i.e. even in absence of the evicted pod. For example, one can
		// prevent all voluntary evictions by specifying 0. This is a
		// mutually exclusive setting with "minAvailable".
		"maxUnavailable"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// An eviction is allowed if at least "minAvailable" pods selected
		// by "selector" will still be available after the eviction, i.e.
		// even in the absence of the evicted pod. So for example you can
		// prevent all voluntary evictions by specifying "100%".
		"minAvailable"?: #."io.k8s.apimachinery.pkg.util.intstr.IntOrString"

		// Label query over pods whose evictions are managed by the
		// disruption budget. A null selector will match no pods, while
		// an empty ({}) selector will select all pods within the
		// namespace.
		"selector"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector"

		// UnhealthyPodEvictionPolicy defines the criteria for when
		// unhealthy pods should be considered for eviction. Current
		// implementation considers healthy pods, as pods that have
		// status.conditions item with type="Ready",status="True".
		//
		// Valid policies are IfHealthyBudget and AlwaysAllow. If no
		// policy is specified, the default behavior will be used, which
		// corresponds to the IfHealthyBudget policy.
		//
		// IfHealthyBudget policy means that running pods
		// (status.phase="Running"), but not yet healthy can be evicted
		// only if the guarded application is not disrupted
		// (status.currentHealthy is at least equal to
		// status.desiredHealthy). Healthy pods will be subject to the
		// PDB for eviction.
		//
		// AlwaysAllow policy means that all running pods
		// (status.phase="Running"), but not yet healthy are considered
		// disrupted and can be evicted regardless of whether the
		// criteria in a PDB is met. This means perspective running pods
		// of a disrupted application might not get a chance to become
		// healthy. Healthy pods will be subject to the PDB for eviction.
		//
		// Additional policies may be added in the future. Clients making
		// eviction decisions should disallow eviction of unhealthy pods
		// if they encounter an unrecognized policy in this field.
		"unhealthyPodEvictionPolicy"?: string
	}

	// Quantity is a fixed-point representation of a number. It
	// provides convenient marshaling/unmarshaling in JSON and YAML,
	// in addition to String() and AsInt64() accessors.
	//
	// The serialization format is:
	//
	// ``` <quantity> ::= <signedNumber><suffix>
	//
	// (Note that <suffix> may be empty, from the "" case in
	// <decimalSI>.)
	//
	// <digit> ::= 0 | 1 | ... | 9 <digits> ::= <digit> |
	// <digit><digits> <number> ::= <digits> | <digits>.<digits> |
	// <digits>. | .<digits> <sign> ::= "+" | "-" <signedNumber> ::=
	// <number> | <sign><number> <suffix> ::= <binarySI> |
	// <decimalExponent> | <decimalSI> <binarySI> ::= Ki | Mi | Gi |
	// Ti | Pi | Ei
	//
	// (International System of units; See:
	// http://physics.nist.gov/cuu/Units/binary.html)
	//
	// <decimalSI> ::= m | "" | k | M | G | T | P | E
	//
	// (Note that 1024 = 1Ki but 1000 = 1k; I didn't choose the
	// capitalization.)
	//
	// <decimalExponent> ::= "e" <signedNumber> | "E" <signedNumber>
	// ```
	//
	// No matter which of the three exponent forms is used, no
	// quantity may represent a number greater than 2^63-1 in
	// magnitude, nor may it have more than 3 decimal places. Numbers
	// larger or more precise will be capped or rounded up. (E.g.:
	// 0.1m will rounded up to 1m.) This may be extended in the
	// future if we require larger or smaller quantities.
	//
	// When a Quantity is parsed from a string, it will remember the
	// type of suffix it had, and will use the same type again when
	// it is serialized.
	//
	// Before serializing, Quantity will be put in "canonical form".
	// This means that Exponent/suffix will be adjusted up or down
	// (with a corresponding increase or decrease in Mantissa) such
	// that:
	//
	// - No precision is lost - No fractional digits will be emitted -
	// The exponent (or suffix) is as large as possible.
	//
	// The sign will be omitted unless the number is negative.
	//
	// Examples:
	//
	// - 1.5 will be serialized as "1500m" - 1.5Gi will be serialized
	// as "1536Mi"
	//
	// Note that the quantity will NEVER be internally represented by
	// a floating point number. That is the whole point of this
	// exercise.
	//
	// Non-canonical values will still parse as long as they are well
	// formed, but will be re-emitted in their canonical form. (So
	// always use canonical form, or don't diff.)
	//
	// This format is intended to make it difficult to use these
	// numbers without writing some sort of special handling code in
	// the hopes that that will cause implementors to also use a
	// fixed point implementation.
	#: "io.k8s.apimachinery.pkg.api.resource.Quantity": string

	// CreateOptions may be provided when creating an API object.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions": {
		// When present, indicates that modifications should not be
		// persisted. An invalid or unrecognized dryRun directive will
		// result in an error response and no further processing of the
		// request. Valid values are:
		// - All: all dry run stages will be processed
		// +optional
		// +listType=atomic
		"dryRun"?: [...string]

		// fieldManager is a name associated with the actor or entity
		// that is making these changes. The value must be less than or
		// 128 characters long, and only contain printable characters,
		// as defined by https://golang.org/pkg/unicode/#IsPrint.
		// +optional
		"fieldManager"?: string

		// fieldValidation instructs the server on how to handle
		// objects in the request (POST/PUT/PATCH) containing unknown
		// or duplicate fields. Valid values are:
		// - Ignore: This will ignore any unknown fields that are silently
		// dropped from the object, and will ignore all but the last
		// duplicate
		// field that the decoder encounters. This is the default behavior
		// prior to v1.23.
		// - Warn: This will send a warning via the standard warning
		// response
		// header for each unknown field that is dropped from the object,
		// and
		// for each duplicate field that is encountered. The request will
		// still succeed if there are no other errors, and will only
		// persist
		// the last of any duplicate fields. This is the default in v1.23+
		// - Strict: This will fail the request with a BadRequest error if
		// any unknown fields would be dropped from the object, or if any
		// duplicate fields are present. The error returned from the
		// server
		// will contain all unknown and duplicate fields encountered.
		// +optional
		"fieldValidation"?: string
	}

	// FieldsV1 stores a set of fields in a data structure like a
	// Trie, in JSON format.
	//
	// Each key is either a '.' representing the field itself, and
	// will always map to an empty set, or a string representing a
	// sub-field or item. The string will follow one of these four
	// formats: 'f:<name>', where <name> is the name of a field in a
	// struct, or key in a map 'v:<value>', where <value> is the
	// exact json formatted value of a list item 'i:<index>', where
	// <index> is position of a item in a list 'k:<keys>', where
	// <keys> is a map of a list item's key fields to their unique
	// values If a key maps to an empty Fields value, the field that
	// key represents is part of the set.
	//
	// The exact format is defined in
	// sigs.k8s.io/structured-merge-diff
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1": {}

	// GroupVersionResource unambiguously identifies a resource. It
	// doesn't anonymously include GroupVersion
	// to avoid automatic coercion. It doesn't use a GroupVersion to
	// avoid custom marshalling
	//
	// +protobuf.options.(gogoproto.goproto_stringer)=false
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.GroupVersionResource": {
		"group"?:    string
		"resource"?: string
		"version"?:  string
	}

	// A label selector is a label query over a set of resources. The
	// result of matchLabels and matchExpressions are ANDed. An empty
	// label selector matches all objects. A null label selector
	// matches no objects.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelector": {
		// matchExpressions is a list of label selector requirements. The
		// requirements are ANDed.
		"matchExpressions"?: [...#."io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement"]

		// matchLabels is a map of {key,value} pairs. A single {key,value}
		// in the matchLabels map is equivalent to an element of
		// matchExpressions, whose key field is "key", the operator is
		// "In", and the values array contains only "value". The
		// requirements are ANDed.
		"matchLabels"?: {
			[string]: string
		}
	}

	// A label selector requirement is a selector that contains
	// values, a key, and an operator that relates the key and
	// values.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.LabelSelectorRequirement": {
		// key is the label key that the selector applies to.
		"key"!: string

		// operator represents a key's relationship to a set of values.
		// Valid operators are In, NotIn, Exists and DoesNotExist.
		"operator"!: string

		// values is an array of string values. If the operator is In or
		// NotIn, the values array must be non-empty. If the operator is
		// Exists or DoesNotExist, the values array must be empty. This
		// array is replaced during a strategic merge patch.
		"values"?: [...string]
	}

	// ListMeta describes metadata that synthetic resources must have,
	// including lists and various status objects. A resource may
	// have only one of {ObjectMeta, ListMeta}.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.ListMeta": {
		// continue may be set if the user set a limit on the number of
		// items returned, and indicates that the server has more data
		// available. The value is opaque and may be used to issue
		// another request to the endpoint that served this list to
		// retrieve the next set of available objects. Continuing a
		// consistent list may not be possible if the server
		// configuration has changed or more than a few minutes have
		// passed. The resourceVersion field returned when using this
		// continue value will be identical to the value in the first
		// response, unless you have received this token from an error
		// message.
		"continue"?: string

		// remainingItemCount is the number of subsequent items in the
		// list which are not included in this list response. If the list
		// request contained label or field selectors, then the number of
		// remaining items is unknown and the field will be left unset
		// and omitted during serialization. If the list is complete
		// (either because it is not chunking or because this is the last
		// chunk), then there are no more remaining items and this field
		// will be left unset and omitted during serialization. Servers
		// older than v1.15 do not set this field. The intended use of
		// the remainingItemCount is *estimating* the size of a
		// collection. Clients should not rely on the remainingItemCount
		// to be set or to be exact.
		"remainingItemCount"?: int

		// String that identifies the server's internal version of this
		// object that can be used by clients to determine when objects
		// have changed. Value must be treated as opaque by clients and
		// passed unmodified back to the server. Populated by the system.
		// Read-only. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
		"resourceVersion"?: string

		// Deprecated: selfLink is a legacy read-only field that is no
		// longer populated by the system.
		"selfLink"?: string
	}

	// ManagedFieldsEntry is a workflow-id, a FieldSet and the group
	// version of the resource that the fieldset applies to.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry": {
		// APIVersion defines the version of this resource that this field
		// set applies to. The format is "group/version" just like the
		// top-level APIVersion field. It is necessary to track the
		// version of a field set because it cannot be automatically
		// converted.
		"apiVersion"?: string

		// FieldsType is the discriminator for the different fields format
		// and version. There is currently only one possible value:
		// "FieldsV1"
		"fieldsType"?: string

		// FieldsV1 holds the first JSON version format as described in
		// the "FieldsV1" type.
		"fieldsV1"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.FieldsV1"

		// Manager is an identifier of the workflow managing these fields.
		"manager"?: string

		// Operation is the type of operation which lead to this
		// ManagedFieldsEntry being created. The only valid values for
		// this field are 'Apply' and 'Update'.
		"operation"?: string

		// Subresource is the name of the subresource used to update that
		// object, or empty string if the object was updated through the
		// main resource. The value of this field is used to distinguish
		// between managers, even if they share the same name. For
		// example, a status update will be distinct from a regular
		// update using the same manager name. Note that the APIVersion
		// field is not related to the Subresource field and it always
		// corresponds to the version of the main resource.
		"subresource"?: string

		// Time is the timestamp of when the ManagedFields entry was
		// added. The timestamp will also be updated if a field is added,
		// the manager changes any of the owned fields value or removes a
		// field. The timestamp does not update when a field is removed
		// from the entry because another manager took it over.
		"time"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"
	}

	// MicroTime is version of Time with microsecond level precision.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.MicroTime": time.Time

	// ObjectMeta is metadata that all persisted resources must have,
	// which includes all objects users must create.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.ObjectMeta": {
		// Annotations is an unstructured key value map stored with a
		// resource that may be set by external tools to store and
		// retrieve arbitrary metadata. They are not queryable and should
		// be preserved when modifying objects. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/annotations
		"annotations"?: [string]: string

		// CreationTimestamp is a timestamp representing the server time
		// when this object was created. It is not guaranteed to be set
		// in happens-before order across separate operations. Clients
		// may not set this value. It is represented in RFC3339 form and
		// is in UTC.
		//
		// Populated by the system. Read-only. Null for lists. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
		"creationTimestamp"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// Number of seconds allowed for this object to gracefully
		// terminate before it will be removed from the system. Only set
		// when deletionTimestamp is also set. May only be shortened.
		// Read-only.
		"deletionGracePeriodSeconds"?: int

		// DeletionTimestamp is RFC 3339 date and time at which this
		// resource will be deleted. This field is set by the server when
		// a graceful deletion is requested by the user, and is not
		// directly settable by a client. The resource is expected to be
		// deleted (no longer visible from resource lists, and not
		// reachable by name) after the time in this field, once the
		// finalizers list is empty. As long as the finalizers list
		// contains items, deletion is blocked. Once the
		// deletionTimestamp is set, this value may not be unset or be
		// set further into the future, although it may be shortened or
		// the resource may be deleted prior to this time. For example, a
		// user may request that a pod is deleted in 30 seconds. The
		// Kubelet will react by sending a graceful termination signal to
		// the containers in the pod. After that 30 seconds, the Kubelet
		// will send a hard termination signal (SIGKILL) to the container
		// and after cleanup, remove the pod from the API. In the
		// presence of network partitions, this object may still exist
		// after this timestamp, until an administrator or automated
		// process can determine the resource is fully terminated. If not
		// set, graceful deletion of the object has not been requested.
		//
		// Populated by the system when a graceful deletion is requested.
		// Read-only. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
		"deletionTimestamp"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// Must be empty before the object is deleted from the registry.
		// Each entry is an identifier for the responsible component that
		// will remove the entry from the list. If the deletionTimestamp
		// of the object is non-nil, entries in this list can only be
		// removed. Finalizers may be processed and removed in any order.
		// Order is NOT enforced because it introduces significant risk
		// of stuck finalizers. finalizers is a shared field, any actor
		// with permission can reorder it. If the finalizer list is
		// processed in order, then this can lead to a situation in which
		// the component responsible for the first finalizer in the list
		// is waiting for a signal (field value, external system, or
		// other) produced by a component responsible for a finalizer
		// later in the list, resulting in a deadlock. Without enforced
		// ordering finalizers are free to order amongst themselves and
		// are not vulnerable to ordering changes in the list.
		"finalizers"?: [...string]

		// GenerateName is an optional prefix, used by the server, to
		// generate a unique name ONLY IF the Name field has not been
		// provided. If this field is used, the name returned to the
		// client will be different than the name passed. This value will
		// also be combined with a unique suffix. The provided value has
		// the same validation rules as the Name field, and may be
		// truncated by the length of the suffix required to make the
		// value unique on the server.
		//
		// If this field is specified and the generated name exists, the
		// server will return a 409.
		//
		// Applied only if Name is not specified. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#idempotency
		"generateName"?: string

		// A sequence number representing a specific generation of the
		// desired state. Populated by the system. Read-only.
		"generation"?: int

		// Map of string keys and values that can be used to organize and
		// categorize (scope and select) objects. May match selectors of
		// replication controllers and services. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels
		"labels"?: {
			[string]: string
		}

		// ManagedFields maps workflow-id and version to the set of fields
		// that are managed by that workflow. This is mostly for internal
		// housekeeping, and users typically shouldn't need to set or
		// understand this field. A workflow can be the user's name, a
		// controller's name, or the name of a specific apply path like
		// "ci-cd". The set of fields is always in the version that the
		// workflow used when modifying the object.
		"managedFields"?: [...#."io.k8s.apimachinery.pkg.apis.meta.v1.ManagedFieldsEntry"]

		// Name must be unique within a namespace. Is required when
		// creating resources, although some resources may allow a client
		// to request the generation of an appropriate name
		// automatically. Name is primarily intended for creation
		// idempotence and configuration definition. Cannot be updated.
		// More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names
		"name"?: string

		// Namespace defines the space within which each name must be
		// unique. An empty namespace is equivalent to the "default"
		// namespace, but "default" is the canonical representation. Not
		// all objects are required to be scoped to a namespace - the
		// value of this field for those objects will be empty.
		//
		// Must be a DNS_LABEL. Cannot be updated. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/namespaces
		"namespace"?: string

		// List of objects depended by this object. If ALL objects in the
		// list have been deleted, this object will be garbage collected.
		// If this object is managed by a controller, then an entry in
		// this list will point to this controller, with the controller
		// field set to true. There cannot be more than one managing
		// controller.
		"ownerReferences"?: [...#."io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference"]

		// An opaque value that represents the internal version of this
		// object that can be used by clients to determine when objects
		// have changed. May be used for optimistic concurrency, change
		// detection, and the watch operation on a resource or set of
		// resources. Clients must treat these values as opaque and
		// passed unmodified back to the server. They may only be valid
		// for a particular resource or set of resources.
		//
		// Populated by the system. Read-only. Value must be treated as
		// opaque by clients and . More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#concurrency-control-and-consistency
		"resourceVersion"?: string

		// Deprecated: selfLink is a legacy read-only field that is no
		// longer populated by the system.
		"selfLink"?: string

		// UID is the unique in time and space value for this object. It
		// is typically generated by the server on successful creation of
		// a resource and is not allowed to change on PUT operations.
		//
		// Populated by the system. Read-only. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids
		"uid"?: string
	}

	// OwnerReference contains enough information to let you identify
	// an owning object. An owning object must be in the same
	// namespace as the dependent, or be cluster-scoped, so there is
	// no namespace field.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.OwnerReference": {
		// API version of the referent.
		"apiVersion"!: string

		// If true, AND if the owner has the "foregroundDeletion"
		// finalizer, then the owner cannot be deleted from the key-value
		// store until this reference is removed. See
		// https://kubernetes.io/docs/concepts/architecture/garbage-collection/#foreground-deletion
		// for how the garbage collector interacts with this field and
		// enforces the foreground deletion. Defaults to false. To set
		// this field, a user needs "delete" permission of the owner,
		// otherwise 422 (Unprocessable Entity) will be returned.
		"blockOwnerDeletion"?: bool

		// If true, this reference points to the managing controller.
		"controller"?: bool

		// Kind of the referent. More info:
		// https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#types-kinds
		"kind"!: string

		// Name of the referent. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names#names
		"name"!: string

		// UID of the referent. More info:
		// https://kubernetes.io/docs/concepts/overview/working-with-objects/names#uids
		"uid"!: string
	}

	// Time is a wrapper around time.Time which supports correct
	// marshaling to YAML and JSON. Wrappers are provided for many of
	// the factory methods that the time package offers.
	#: "io.k8s.apimachinery.pkg.apis.meta.v1.Time": time.Time

	#: "io.k8s.apimachinery.pkg.util.intstr.IntOrString": string

	#: "sensor.CreateSensorRequest": {
		"createOptions"?: #."io.k8s.apimachinery.pkg.apis.meta.v1.CreateOptions"
		"namespace"?:     string
		"sensor"?:        #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Sensor"
	}

	#: "sensor.DeleteSensorResponse": {}

	// structured log entry
	#: "sensor.LogEntry": {
		// optional - trigger dependency name
		"dependencyName"?: string

		// optional - Cloud Event context
		"eventContext"?: string
		"level"?:        string
		"msg"?:          string
		"namespace"?:    string
		"sensorName"?:   string
		"time"?:         #."io.k8s.apimachinery.pkg.apis.meta.v1.Time"

		// optional - any trigger name
		"triggerName"?: string
	}

	#: "sensor.SensorWatchEvent": {
		"object"?: #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Sensor"
		"type"?:   string
	}

	#: "sensor.UpdateSensorRequest": {
		"name"?:      string
		"namespace"?: string
		"sensor"?:    #."github.com.argoproj.argo_events.pkg.apis.events.v1alpha1.Sensor"
	}

	#: "sync.CreateSyncLimitRequest": {
		"cmName"?:    string
		"key"?:       string
		"limit"?:     int
		"namespace"?: string
		"type"?:      #."sync.SyncConfigType"
	}

	#: "sync.DeleteSyncLimitResponse": {}

	#: "sync.SyncConfigType": "CONFIGMAP" | "DATABASE"

	#: "sync.SyncLimitResponse": {
		"cmName"?:    string
		"key"?:       string
		"limit"?:     int
		"namespace"?: string
		"type"?:      #."sync.SyncConfigType"
	}

	#: "sync.UpdateSyncLimitRequest": {
		"cmName"?:    string
		"key"?:       string
		"limit"?:     int
		"namespace"?: string
		"type"?:      #."sync.SyncConfigType"
	}
}