model

type AsyncAPIArguments struct {
	Document       *ExternalResource                  `json:"document" validate:"required"`
	Channel        string                             `json:"channel,omitempty"`
	Operation      string                             `json:"operation,omitempty"`
	Server         *AsyncAPIServer                    `json:"server,omitempty"`
	Protocol       string                             `` /* 169-byte string literal not displayed */
	Message        *AsyncAPIOutboundMessage           `json:"message,omitempty"`
	Subscription   *AsyncAPISubscription              `json:"subscription,omitempty"`
	Authentication *ReferenceableAuthenticationPolicy `json:"authentication,omitempty" validate:"omitempty"`
}

type AsyncAPIMessageConsumptionPolicy struct {
	For    *Duration          `json:"for,omitempty"`
	Amount int                `json:"amount,omitempty" validate:"required_without_all=While Until"`
	While  *RuntimeExpression `json:"while,omitempty" validate:"required_without_all=Amount Until"`
	Until  *RuntimeExpression `json:"until,omitempty" validate:"required_without_all=Amount While"`
}

type AsyncAPIOutboundMessage struct {
	Payload map[string]interface{} `json:"payload,omitempty" validate:"omitempty"`
	Headers map[string]interface{} `json:"headers,omitempty" validate:"omitempty"`
}

type AsyncAPIServer struct {
	Name      string                 `json:"name" validate:"required"`
	Variables map[string]interface{} `json:"variables,omitempty"`
}

type AsyncAPISubscription struct {
	Filter  *RuntimeExpression                `json:"filter,omitempty"`
	Consume *AsyncAPIMessageConsumptionPolicy `json:"consume" validate:"required"`
}

type AuthenticationPolicy struct {
	Basic  *BasicAuthenticationPolicy         `json:"basic,omitempty"`
	Bearer *BearerAuthenticationPolicy        `json:"bearer,omitempty"`
	Digest *DigestAuthenticationPolicy        `json:"digest,omitempty"`
	OAuth2 *OAuth2AuthenticationPolicy        `json:"oauth2,omitempty"`
	OIDC   *OpenIdConnectAuthenticationPolicy `json:"oidc,omitempty"`
}

type BackoffDefinition struct {
	Definition map[string]interface{} `json:"definition,omitempty"`
}

type BasicAuthenticationPolicy struct {
	Username string `json:"username,omitempty" validate:"required_without=Use"`
	Password string `json:"password,omitempty" validate:"required_without=Use"`
	Use      string `json:"use,omitempty" validate:"required_without_all=Username Password,basic_policy"`
}

type BearerAuthenticationPolicy struct {
	Token string `json:"token,omitempty" validate:"required_without=Use,bearer_policy"`
	Use   string `json:"use,omitempty" validate:"required_without=Token"`
}

type CallAsyncAPI struct {
	TaskBase `json:",inline"`
	Call     string            `json:"call" validate:"required,eq=asyncapi"`
	With     AsyncAPIArguments `json:"with" validate:"required"`
}

type CallFunction struct {
	TaskBase `json:",inline"`       // Inline TaskBase fields
	Call     string                 `json:"call" validate:"required"`
	With     map[string]interface{} `json:"with,omitempty"`
}

type CallGRPC struct {
	TaskBase `json:",inline"`
	Call     string        `json:"call" validate:"required,eq=grpc"`
	With     GRPCArguments `json:"with" validate:"required"`
}

type CallHTTP struct {
	TaskBase `json:",inline"` // Inline TaskBase fields
	Call     string           `json:"call" validate:"required,eq=http"`
	With     HTTPArguments    `json:"with" validate:"required"`
}

type CallOpenAPI struct {
	TaskBase `json:",inline"` // Inline TaskBase fields
	Call     string           `json:"call" validate:"required,eq=openapi"`
	With     OpenAPIArguments `json:"with" validate:"required"`
}

type Catalog struct {
	Endpoint *Endpoint `json:"endpoint" validate:"required"`
}

type Container struct {
	Image       string                 `json:"image" validate:"required"`
	Command     string                 `json:"command,omitempty"`
	Ports       map[string]interface{} `json:"ports,omitempty"`
	Volumes     map[string]interface{} `json:"volumes,omitempty"`
	Environment map[string]string      `json:"environment,omitempty"`
}

type Correlation struct {
	From   string `json:"from" validate:"required"` // Runtime expression to extract the correlation value
	Expect string `json:"expect,omitempty"`         // Expected value or runtime expression
}

type DigestAuthenticationPolicy struct {
	Username string `json:"username,omitempty" validate:"required_without=Use"`
	Password string `json:"password,omitempty" validate:"required_without=Use"`
	Use      string `json:"use,omitempty" validate:"required_without_all=Username Password,digest_policy"`
}

type DoTask struct {
	TaskBase `json:",inline"` // Inline TaskBase fields
	Do       *TaskList        `json:"do" validate:"required,dive"`
}

type Document struct {
	DSL       string                 `json:"dsl" yaml:"dsl" validate:"required,semver_pattern"`
	Namespace string                 `json:"namespace" yaml:"namespace" validate:"required,hostname_rfc1123"`
	Name      string                 `json:"name" yaml:"name" validate:"required,hostname_rfc1123"`
	Version   string                 `json:"version" yaml:"version" validate:"required,semver_pattern"`
	Title     string                 `json:"title,omitempty" yaml:"title,omitempty"`
	Summary   string                 `json:"summary,omitempty" yaml:"summary,omitempty"`
	Tags      map[string]string      `json:"tags,omitempty" yaml:"tags,omitempty"`
	Metadata  map[string]interface{} `json:"metadata,omitempty" yaml:"metadata,omitempty"`
}

type Duration struct {
	Value interface{} `json:"-"`
}

type DurationExpression struct {
	Expression string `json:"-" validate:"required,iso8601_duration"`
}

type DurationInline struct {
	Days         int32 `json:"days,omitempty"`
	Hours        int32 `json:"hours,omitempty"`
	Minutes      int32 `json:"minutes,omitempty"`
	Seconds      int32 `json:"seconds,omitempty"`
	Milliseconds int32 `json:"milliseconds,omitempty"`
}

type EmitEventDefinition struct {
	With *EventProperties `json:"with" validate:"required"`
}

type EmitTask struct {
	TaskBase `json:",inline"`      // Inline TaskBase fields
	Emit     EmitTaskConfiguration `json:"emit" validate:"required"`
}

type EmitTaskConfiguration struct {
	Event EmitEventDefinition `json:"event" validate:"required"`
}

type Endpoint struct {
	RuntimeExpression *RuntimeExpression     `json:"-"`
	URITemplate       URITemplate            `json:"-"`
	EndpointConfig    *EndpointConfiguration `json:"-"`
}

type EndpointConfiguration struct {
	RuntimeExpression *RuntimeExpression                 `json:"-"`
	URI               URITemplate                        `json:"uri" validate:"required"`
	Authentication    *ReferenceableAuthenticationPolicy `json:"authentication,omitempty"`
}

type Error struct {
	// A URI reference that identifies the error type.
	// For cross-compatibility concerns, it is strongly recommended to use Standard Error Types whenever possible.
	// Runtimes MUST ensure that the property has been set when raising or escalating the error.
	Type *URITemplateOrRuntimeExpr `json:"type" validate:"required"`
	// The status code generated by the origin for this occurrence of the error.
	// For cross-compatibility concerns, it is strongly recommended to use HTTP Status Codes whenever possible.
	// Runtimes MUST ensure that the property has been set when raising or escalating the error.
	Status int `json:"status" validate:"required"`
	// A short, human-readable summary of the error.
	Title *StringOrRuntimeExpr `json:"title,omitempty"`
	// A human-readable explanation specific to this occurrence of the error.
	Detail *StringOrRuntimeExpr `json:"detail,omitempty"`
	// A JSON Pointer used to reference the component the error originates from.
	// Runtimes MUST set the property when raising or escalating the error. Otherwise ignore.
	Instance *JsonPointerOrRuntimeExpression `json:"instance,omitempty" validate:"omitempty"`
}

type ErrorFilter struct {
	Type     string `json:"type,omitempty"`
	Status   int    `json:"status,omitempty"`
	Instance string `json:"instance,omitempty"`
	Title    string `json:"title,omitempty"`
	Details  string `json:"details,omitempty"`
}

type EventConsumptionStrategy struct {
	All   []*EventFilter         `json:"all,omitempty" validate:"omitempty,dive"`
	Any   []*EventFilter         `json:"any,omitempty" validate:"omitempty,dive"`
	One   *EventFilter           `json:"one,omitempty" validate:"omitempty"`
	Until *EventConsumptionUntil `json:"until,omitempty" validate:"omitempty"`
}

type EventConsumptionUntil struct {
	Condition  *RuntimeExpression        `json:"-" validate:"omitempty"`
	Strategy   *EventConsumptionStrategy `json:"-" validate:"omitempty"`
	IsDisabled bool                      `json:"-"` // True when "until: false"
}

type EventFilter struct {
	With      *EventProperties       `json:"with" validate:"required"`
	Correlate map[string]Correlation `json:"correlate,omitempty" validate:"omitempty,dive"` // Keyed correlation filters
}

type EventProperties struct {
	ID              string                    `json:"id,omitempty"`
	Source          *URITemplateOrRuntimeExpr `json:"source,omitempty" validate:"omitempty"` // URI template or runtime expression
	Type            string                    `json:"type,omitempty"`
	Time            *StringOrRuntimeExpr      `json:"time,omitempty" validate:"omitempty,string_or_runtime_expr"` // ISO 8601 date-time string or runtime expression
	Subject         string                    `json:"subject,omitempty"`
	DataContentType string                    `json:"datacontenttype,omitempty"`
	DataSchema      *URITemplateOrRuntimeExpr `json:"dataschema,omitempty" validate:"omitempty"` // URI template or runtime expression
	Additional      map[string]interface{}    `json:"-"`
}

type Export struct {
	Schema *Schema              `json:"schema,omitempty" validate:"omitempty"`
	As     *ObjectOrRuntimeExpr `json:"as,omitempty" validate:"omitempty"`
}

type Extension struct {
	Extend string             `json:"extend" validate:"required,oneof=call composite emit for listen raise run set switch try wait all"`
	When   *RuntimeExpression `json:"when,omitempty"`
	Before *TaskList          `json:"before,omitempty" validate:"omitempty,dive"`
	After  *TaskList          `json:"after,omitempty" validate:"omitempty,dive"`
}

type ExtensionItem struct {
	Key       string     `json:"-" validate:"required"`
	Extension *Extension `json:"-" validate:"required"`
}

type ExtensionList []*ExtensionItem

type ExternalResource struct {
	Name     string    `json:"name,omitempty"`
	Endpoint *Endpoint `json:"endpoint" validate:"required"`
}

type FlowDirective struct {
	Value string `json:"-" validate:"required"` // Ensure the value is non-empty.
}

type FlowDirectiveType string

type ForTask struct {
	TaskBase `json:",inline"`     // Inline TaskBase fields
	For      ForTaskConfiguration `json:"for" validate:"required"`
	While    string               `json:"while,omitempty"`
	Do       *TaskList            `json:"do" validate:"required,dive"`
}

type ForTaskConfiguration struct {
	Each string `json:"each,omitempty"`         // Variable name for the current item
	In   string `json:"in" validate:"required"` // Runtime expression for the collection
	At   string `json:"at,omitempty"`           // Variable name for the current index
}

type ForkTask struct {
	TaskBase `json:",inline"`      // Inline TaskBase fields
	Fork     ForkTaskConfiguration `json:"fork" validate:"required"`
}

type ForkTaskConfiguration struct {
	Branches *TaskList `json:"branches" validate:"required,dive"`
	Compete  bool      `json:"compete,omitempty"`
}

type GRPCArguments struct {
	Proto          *ExternalResource                  `json:"proto" validate:"required"`
	Service        GRPCService                        `json:"service" validate:"required"`
	Method         string                             `json:"method" validate:"required"`
	Arguments      map[string]interface{}             `json:"arguments,omitempty"`
	Authentication *ReferenceableAuthenticationPolicy `json:"authentication,omitempty" validate:"omitempty"`
}

type GRPCService struct {
	Name           string                             `json:"name" validate:"required"`
	Host           string                             `json:"host" validate:"required,hostname_rfc1123"`
	Port           int                                `json:"port" validate:"required,min=0,max=65535"`
	Authentication *ReferenceableAuthenticationPolicy `json:"authentication,omitempty"`
}

type HTTPArguments struct {
	Method   string                 `json:"method" validate:"required,oneofci=GET POST PUT DELETE PATCH"`
	Endpoint *Endpoint              `json:"endpoint" validate:"required"`
	Headers  map[string]string      `json:"headers,omitempty"`
	Body     json.RawMessage        `json:"body,omitempty"`
	Query    map[string]interface{} `json:"query,omitempty"`
	Output   string                 `json:"output,omitempty" validate:"omitempty,oneof=raw content response"`
}

type Input struct {
	Schema *Schema              `json:"schema,omitempty" validate:"omitempty"`
	From   *ObjectOrRuntimeExpr `json:"from,omitempty" validate:"omitempty"`
}

type JsonPointerOrRuntimeExpression struct {
	Value interface{} `json:"-" validate:"json_pointer_or_runtime_expr"` // Custom validation tag.
}

type ListenTask struct {
	TaskBase `json:",inline"`        // Inline TaskBase fields
	Listen   ListenTaskConfiguration `json:"listen" validate:"required"`
}

type ListenTaskConfiguration struct {
	To *EventConsumptionStrategy `json:"to" validate:"required"`
}

type LiteralUri struct {
	Value string `json:"-" validate:"required,uri_pattern"` // Validate pattern for URI.
}

type LiteralUriTemplate struct {
	Value string `json:"-" validate:"required,uri_template_pattern"` // Validate pattern for URI template.
}

type NamedTaskMap map[string]Task

type OAuth2AutenthicationDataClient struct {
	ID             string                        `json:"id,omitempty"`
	Secret         string                        `json:"secret,omitempty"`
	Assertion      string                        `json:"assertion,omitempty"`
	Authentication OAuthClientAuthenticationType `json:"authentication,omitempty" validate:"client_auth_type"`
}

type OAuth2AuthenticationDataGrant string

type OAuth2AuthenticationPolicy struct {
	Properties *OAuth2AuthenticationProperties `json:",omitempty" validate:"required_without=Use"`
	Endpoints  *OAuth2Endpoints                `json:"endpoints,omitempty"`
	Use        string                          `json:"use,omitempty" validate:"oauth2_policy"`
}

type OAuth2AuthenticationProperties struct {
	Authority URITemplate                     `json:"authority,omitempty"`
	Grant     OAuth2AuthenticationDataGrant   `` /* 158-byte string literal not displayed */
	Client    *OAuth2AutenthicationDataClient `json:"client,omitempty"`
	Request   *OAuth2TokenRequest             `json:"request,omitempty"`
	Issuers   []string                        `json:"issuers,omitempty"`
	Scopes    []string                        `json:"scopes,omitempty"`
	Audiences []string                        `json:"audiences,omitempty"`
	Username  string                          `json:"username,omitempty"`
	Password  string                          `json:"password,omitempty"`
	Subject   *OAuth2Token                    `json:"subject,omitempty"`
	Actor     *OAuth2Token                    `json:"actor,omitempty"`
}

type OAuth2Endpoints struct {
	Token         string `json:"token,omitempty"`
	Revocation    string `json:"revocation,omitempty"`
	Introspection string `json:"introspection,omitempty"`
}

type OAuth2Token struct {
	// Token The security token to use
	Token string `json:"token,omitempty"`
	// Type The type of the security token to use.
	Type string `json:"type,omitempty"`
}

type OAuth2TokenRequest struct {
	Encoding OAuth2TokenRequestEncodingType `json:"encoding" validate:"encoding_type"`
}

type OAuth2TokenRequestEncodingType string

type OAuthClientAuthenticationType string

type Object interface {
	String() string
	GetValue() interface{}
}

type ObjectOrRuntimeExpr struct {
	Value interface{} `json:"-" validate:"object_or_runtime_expr"` // Custom validation tag.
}

type ObjectOrString struct {
	Value interface{} `validate:"object_or_string"`
}

type OpenAPIArguments struct {
	Document       *ExternalResource                  `json:"document" validate:"required"`
	OperationID    string                             `json:"operationId" validate:"required"`
	Parameters     map[string]interface{}             `json:"parameters,omitempty"`
	Authentication *ReferenceableAuthenticationPolicy `json:"authentication,omitempty"`
	Output         string                             `json:"output,omitempty" validate:"omitempty,oneof=raw content response"`
}

type OpenIdConnectAuthenticationPolicy struct {
	Properties *OAuth2AuthenticationProperties `json:",omitempty" validate:"omitempty,required_without=Use"`
	Use        string                          `json:"use,omitempty" validate:"omitempty,required_without=Properties"`
}

type Output struct {
	Schema *Schema              `json:"schema,omitempty" validate:"omitempty"`
	As     *ObjectOrRuntimeExpr `json:"as,omitempty" validate:"omitempty"`
}

type RaiseTask struct {
	TaskBase `json:",inline"`       // Inline TaskBase fields
	Raise    RaiseTaskConfiguration `json:"raise" validate:"required"`
}

type RaiseTaskConfiguration struct {
	Error RaiseTaskError `json:"error" validate:"required"`
}

type RaiseTaskError struct {
	Definition *Error  `json:"-"`
	Ref        *string `json:"-"`
}

type ReferenceableAuthenticationPolicy struct {
	Use                  *string               `json:"use,omitempty"`
	AuthenticationPolicy *AuthenticationPolicy `json:",inline"`
}

type RetryBackoff struct {
	Constant    *BackoffDefinition `json:"constant,omitempty"`
	Exponential *BackoffDefinition `json:"exponential,omitempty"`
	Linear      *BackoffDefinition `json:"linear,omitempty"`
}

type RetryLimit struct {
	Attempt  *RetryLimitAttempt `json:"attempt,omitempty"`
	Duration *Duration          `json:"duration,omitempty"`
}

type RetryLimitAttempt struct {
	Count    int       `json:"count,omitempty"`
	Duration *Duration `json:"duration,omitempty"`
}

type RetryPolicy struct {
	When       *RuntimeExpression `json:"when,omitempty"`
	ExceptWhen *RuntimeExpression `json:"exceptWhen,omitempty"`
	Delay      *Duration          `json:"delay,omitempty"`
	Backoff    *RetryBackoff      `json:"backoff,omitempty"`
	Limit      RetryLimit         `json:"limit,omitempty"`
	Jitter     *RetryPolicyJitter `json:"jitter,omitempty"`
	Ref        string             `json:"-"` // Reference to a reusable retry policy
}

type RetryPolicyJitter struct {
	From *Duration `json:"from" validate:"required"`
	To   *Duration `json:"to" validate:"required"`
}

type RunTask struct {
	TaskBase `json:",inline"`     // Inline TaskBase fields
	Run      RunTaskConfiguration `json:"run" validate:"required"`
}

type RunTaskConfiguration struct {
	Await     *bool        `json:"await,omitempty"`
	Container *Container   `json:"container,omitempty"`
	Script    *Script      `json:"script,omitempty"`
	Shell     *Shell       `json:"shell,omitempty"`
	Workflow  *RunWorkflow `json:"workflow,omitempty"`
}

type RunWorkflow struct {
	Namespace string                 `json:"namespace" validate:"required,hostname_rfc1123"`
	Name      string                 `json:"name" validate:"required,hostname_rfc1123"`
	Version   string                 `json:"version" validate:"required,semver_pattern"`
	Input     map[string]interface{} `json:"input,omitempty"`
}

type RuntimeExpression struct {
	Value string `json:"-" validate:"required"`
}

type Schedule struct {
	Every *Duration                 `json:"every,omitempty" validate:"omitempty"`
	Cron  string                    `json:"cron,omitempty" validate:"omitempty"`
	After *Duration                 `json:"after,omitempty" validate:"omitempty"`
	On    *EventConsumptionStrategy `json:"on,omitempty" validate:"omitempty"`
}

type Schema struct {
	Format   string            `json:"format,omitempty"`
	Document interface{}       `json:"document,omitempty" validate:"omitempty"`
	Resource *ExternalResource `json:"resource,omitempty" validate:"omitempty"`
}

type Script struct {
	Language    string                 `json:"language" validate:"required"`
	Arguments   map[string]interface{} `json:"arguments,omitempty"`
	Environment map[string]string      `json:"environment,omitempty"`
	InlineCode  *string                `json:"code,omitempty"`
	External    *ExternalResource      `json:"source,omitempty"`
}

type SetTask struct {
	TaskBase `json:",inline"`       // Inline TaskBase fields
	Set      map[string]interface{} `json:"set" validate:"required,min=1,dive"`
}

type Shell struct {
	Command     string                 `json:"command" validate:"required"`
	Arguments   map[string]interface{} `json:"arguments,omitempty"`
	Environment map[string]string      `json:"environment,omitempty"`
}

type StringOrRuntimeExpr struct {
	Value interface{} `json:"-" validate:"string_or_runtime_expr"` // Custom validation tag.
}

type SwitchCase struct {
	When *RuntimeExpression `json:"when,omitempty"`
	Then *FlowDirective     `json:"then" validate:"required"`
}

type SwitchItem map[string]SwitchCase

type SwitchTask struct {
	TaskBase `json:",inline"` // Inline TaskBase fields
	Switch   []SwitchItem     `json:"switch" validate:"required,min=1,dive,switch_item"`
}

type Task interface {
	GetBase() *TaskBase
}

type TaskBase struct {
	// A runtime expression, if any, used to determine whether or not the task should be run.
	If *RuntimeExpression `json:"if,omitempty" validate:"omitempty"`
	// Configure the task's input.
	Input *Input `json:"input,omitempty" validate:"omitempty"`
	// Configure the task's output.
	Output *Output `json:"output,omitempty" validate:"omitempty"`
	// Export task output to context.
	Export  *Export             `json:"export,omitempty" validate:"omitempty"`
	Timeout *TimeoutOrReference `json:"timeout,omitempty" validate:"omitempty"`
	// The flow directive to be performed upon completion of the task.
	Then     *FlowDirective         `json:"then,omitempty" validate:"omitempty"`
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type TaskItem struct {
	Key  string `json:"-" validate:"required"`
	Task Task   `json:"-" validate:"required"`
}

type TaskList []*TaskItem

type Timeout struct {
	// After The duration after which to timeout
	After *Duration `json:"after" validate:"required"`
}

type TimeoutOrReference struct {
	Timeout   *Timeout `json:"-" validate:"required_without=Ref"`
	Reference *string  `json:"-" validate:"required_without=Timeout"`
}

type TryTask struct {
	TaskBase `json:",inline"`
	Try      *TaskList     `json:"try" validate:"required,dive"`
	Catch    *TryTaskCatch `json:"catch" validate:"required"`
}

type TryTaskCatch struct {
	Errors struct {
		With *ErrorFilter `json:"with,omitempty"`
	} `json:"errors,omitempty"`
	As         string             `json:"as,omitempty"`
	When       *RuntimeExpression `json:"when,omitempty"`
	ExceptWhen *RuntimeExpression `json:"exceptWhen,omitempty"`
	Retry      *RetryPolicy       `json:"retry,omitempty"`
	Do         *TaskList          `json:"do,omitempty" validate:"omitempty,dive"`
}

type URITemplate interface {
	IsURITemplate() bool
	String() string
	GetValue() interface{}
}

type URITemplateOrRuntimeExpr struct {
	Value interface{} `json:"-" validate:"uri_template_or_runtime_expr"` // Custom validation.
}

type Use struct {
	Authentications map[string]*AuthenticationPolicy `json:"authentications,omitempty" validate:"omitempty,dive"`
	Errors          map[string]*Error                `json:"errors,omitempty" validate:"omitempty,dive"`
	Extensions      ExtensionList                    `json:"extensions,omitempty" validate:"omitempty,dive"`
	Functions       NamedTaskMap                     `json:"functions,omitempty" validate:"omitempty,dive"`
	Retries         map[string]*RetryPolicy          `json:"retries,omitempty" validate:"omitempty,dive"`
	Secrets         []string                         `json:"secrets,omitempty"`
	Timeouts        map[string]*Timeout              `json:"timeouts,omitempty" validate:"omitempty,dive"`
	Catalogs        map[string]*Catalog              `json:"catalogs,omitempty" validate:"omitempty,dive"`
}

type WaitTask struct {
	TaskBase `json:",inline"`
	Wait     *Duration `json:"wait" validate:"required"`
}

type Workflow struct {
	Document Document            `json:"document" yaml:"document" validate:"required"`
	Input    *Input              `json:"input,omitempty" yaml:"input,omitempty"`
	Use      *Use                `json:"use,omitempty" yaml:"use"`
	Do       *TaskList           `json:"do" yaml:"do" validate:"required,dive"`
	Timeout  *TimeoutOrReference `json:"timeout,omitempty" yaml:"timeout,omitempty"`
	Output   *Output             `json:"output,omitempty" yaml:"output,omitempty"`
	Schedule *Schedule           `json:"schedule,omitempty" yaml:"schedule,omitempty"`
}

type WorkflowBuilder struct {
	// contains filtered or unexported fields
}