model

type Action struct {
	// Defines Unique action identifier.
	// +optional
	ID string `json:"id,omitempty"`
	// Defines Unique action name.
	// +optional
	Name string `json:"name,omitempty"`
	// References a reusable function definition.
	// +optional
	FunctionRef *FunctionRef `json:"functionRef,omitempty"`
	// References a 'trigger' and 'result' reusable event definitions.
	// +optional
	EventRef *EventRef `json:"eventRef,omitempty"`
	// References a workflow to be invoked.
	// +optional
	SubFlowRef *WorkflowRef `json:"subFlowRef,omitempty"`
	// Defines time period workflow execution should sleep before / after function execution.
	// +optional
	Sleep *Sleep `json:"sleep,omitempty"`
	// References a defined workflow retry definition. If not defined uses the default runtime retry definition.
	// +optional
	RetryRef string `json:"retryRef,omitempty"`
	// List of unique references to defined workflow errors for which the action should not be retried.
	// Used only when `autoRetries` is set to `true`
	// +optional
	NonRetryableErrors []string `json:"nonRetryableErrors,omitempty" validate:"omitempty,min=1"`
	// List of unique references to defined workflow errors for which the action should be retried.
	// Used only when `autoRetries` is set to `false`
	// +optional
	RetryableErrors []string `json:"retryableErrors,omitempty" validate:"omitempty,min=1"`
	// Filter the state data to select only the data that can be used within function definition arguments
	// using its fromStateData property. Filter the action results to select only the result data that should
	// be added/merged back into the state data using its results property. Select the part of state data which
	// the action data results should be added/merged to using the toStateData property.
	// +optional
	ActionDataFilter ActionDataFilter `json:"actionDataFilter,omitempty"`
	// Expression, if defined, must evaluate to true for this action to be performed. If false, action is disregarded.
	// +optional
	Condition string `json:"condition,omitempty"`
}

type ActionDataFilter struct {
	// Workflow expression that filters state data that can be used by the action.
	// +optional
	// +optional
	FromStateData string `json:"fromStateData,omitempty"`
	// If set to false, action data results are not added/merged to state data. In this case 'results'
	// and 'toStateData' should be ignored. Default is true.
	// +optional
	UseResults bool `json:"useResults,omitempty"`
	// Workflow expression that filters the actions data results.
	// +optional
	Results string `json:"results,omitempty"`
	// Workflow expression that selects a state data element to which the action results should be
	// added/merged into. If not specified denotes the top-level state data element.
	// +optional
	ToStateData string `json:"toStateData,omitempty"`
}

type ActionMode string

type Auth struct {
	// Unique auth definition name.
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// Auth scheme, can be "basic", "bearer", or "oauth2". Default is "basic"
	// +kubebuilder:validation:Enum=basic;bearer;oauth2
	// +kubebuilder:default=basic
	// +kubebuilder:validation:Required
	Scheme AuthType `json:"scheme" validate:"required,oneofkind"`
	// Auth scheme properties. Can be one of "Basic properties definition", "Bearer properties definition",
	// or "OAuth2 properties definition"
	// +kubebuilder:validation:Required
	Properties AuthProperties `json:"properties" validate:"required"`
}

type AuthProperties struct {
	Basic  *BasicAuthProperties  `json:",omitempty"`
	Bearer *BearerAuthProperties `json:",omitempty"`
	OAuth2 *OAuth2AuthProperties `json:",omitempty"`
}

type AuthType string

type Auths []Auth

type BaseState struct {
	// Unique State id.
	// +optional
	ID string `json:"id,omitempty"`
	// State name.
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// stateType can be any of delay, callback, event, foreach, inject, operation, parallel, sleep, switch
	// +kubebuilder:validation:Enum:=delay;callback;event;foreach;inject;operation;parallel;sleep;switch
	// +kubebuilder:validation:Required
	Type StateType `json:"type" validate:"required,oneofkind"`
	// States error handling and retries definitions.
	// +optional
	OnErrors []OnError `json:"onErrors,omitempty"  validate:"omitempty,dive"`
	// Next transition of the workflow after the time delay.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Transition *Transition `json:"transition,omitempty"`
	// State data filter.
	// +optional
	StateDataFilter *StateDataFilter `json:"stateDataFilter,omitempty"`
	// Unique Name of a workflow state which is responsible for compensation of this state.
	// +optional
	CompensatedBy string `json:"compensatedBy,omitempty"`
	// If true, this state is used to compensate another state. Default is false.
	// +optional
	UsedForCompensation bool `json:"usedForCompensation,omitempty"`
	// State end definition.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	End *End `json:"end,omitempty"`
	// Metadata information.
	// +optional
	Metadata *Metadata `json:"metadata,omitempty"`
}

type BaseWorkflow struct {
	// Workflow unique identifier
	// +optional
	ID string `json:"id,omitempty" validate:"required_without=Key"`
	// Key Domain-specific workflow identifier
	// +optional
	Key string `json:"key,omitempty" validate:"required_without=ID"`
	// Workflow name
	Name string `json:"name,omitempty"`
	// Workflow description.
	// +optional
	Description string `json:"description,omitempty"`
	// Workflow version.
	// +optional
	Version string `json:"version" validate:"omitempty,min=1"`
	// Workflow start definition.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Start *Start `json:"start,omitempty"`
	// Annotations List of helpful terms describing the workflows intended purpose, subject areas, or other important
	// qualities.
	// +optional
	Annotations []string `json:"annotations,omitempty"`
	// DataInputSchema URI of the JSON Schema used to validate the workflow data input
	// +optional
	DataInputSchema *DataInputSchema `json:"dataInputSchema,omitempty"`
	// Serverless Workflow schema version
	// +kubebuilder:validation:Required
	// +kubebuilder:default="0.8"
	SpecVersion string `json:"specVersion" validate:"required"`
	// Secrets allow you to access sensitive information, such as passwords, OAuth tokens, ssh keys, etc,
	// inside your Workflow Expressions.
	// +optional
	Secrets Secrets `json:"secrets,omitempty" validate:"unique"`
	// Constants Workflow constants are used to define static, and immutable, data which is available to
	// Workflow Expressions.
	// +optional
	Constants *Constants `json:"constants,omitempty"`
	// Identifies the expression language used for workflow expressions. Default is 'jq'.
	// +kubebuilder:validation:Enum=jq;jsonpath;cel
	// +kubebuilder:default=jq
	// +optional
	ExpressionLang ExpressionLangType `json:"expressionLang,omitempty" validate:"required,oneofkind"`
	// Defines the workflow default timeout settings.
	// +optional
	Timeouts *Timeouts `json:"timeouts,omitempty"`
	// Defines checked errors that can be explicitly handled during workflow execution.
	// +optional
	Errors Errors `json:"errors,omitempty" validate:"unique=Name,dive"`
	// If "true", workflow instances is not terminated when there are no active execution paths.
	// Instance can be terminated with "terminate end definition" or reaching defined "workflowExecTimeout"
	// +optional
	KeepActive bool `json:"keepActive,omitempty"`
	// Metadata custom information shared with the runtime.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Metadata Metadata `json:"metadata,omitempty"`
	// AutoRetries If set to true, actions should automatically be retried on unchecked errors. Default is false
	// +optional
	AutoRetries bool `json:"autoRetries,omitempty"`
	// Auth definitions can be used to define authentication information that should be applied to resources defined
	// in the operation property of function definitions. It is not used as authentication information for the
	// function invocation, but just to access the resource containing the function invocation information.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Auth Auths `json:"auth,omitempty" validate:"unique=Name,dive"`
}

type BasicAuthProperties struct {
	Common `json:",inline"`
	// Secret Expression referencing a workflow secret that contains all needed auth info
	// +optional
	Secret string `json:"secret,omitempty"`
	// Username String or a workflow expression. Contains the username
	// +kubebuilder:validation:Required
	Username string `json:"username" validate:"required"`
	// Password String or a workflow expression. Contains the user password
	// +kubebuilder:validation:Required
	Password string `json:"password" validate:"required"`
}

type BearerAuthProperties struct {
	Common `json:",inline"`
	// Secret Expression referencing a workflow secret that contains all needed auth info
	// +optional
	Secret string `json:"secret,omitempty"`
	// Token String or a workflow expression. Contains the token
	// +kubebuilder:validation:Required
	Token string `json:"token" validate:"required"`
}

type Branch struct {
	// Branch name
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// Actions to be executed in this branch
	// +kubebuilder:validation:MinItems=1
	Actions []Action `json:"actions" validate:"required,min=1,dive"`
	// Branch specific timeout settings
	// +optional
	Timeouts *BranchTimeouts `json:"timeouts,omitempty"`
}

type BranchTimeouts struct {
	// Single actions definition execution timeout duration (ISO 8601 duration format)
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
	// Single branch execution timeout duration (ISO 8601 duration format)
	// +optional
	BranchExecTimeout string `json:"branchExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type CallbackState struct {
	// Defines the action to be executed.
	// +kubebuilder:validation:Required
	Action Action `json:"action"`
	// References a unique callback event name in the defined workflow events.
	// +kubebuilder:validation:Required
	EventRef string `json:"eventRef" validate:"required"`
	// Time period to wait for incoming events (ISO 8601 format)
	// +optional
	Timeouts *CallbackStateTimeout `json:"timeouts,omitempty"`
	// Event data filter definition.
	// +optional
	EventDataFilter *EventDataFilter `json:"eventDataFilter,omitempty"`
}

type CallbackStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Default single actions definition execution timeout (ISO 8601 duration format)
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
	// Default timeout for consuming defined events (ISO 8601 duration format)
	// +optional
	EventTimeout string `json:"eventTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type Common struct {
	// Metadata information
	// +optional
	Metadata Metadata `json:"metadata,omitempty"`
}

type CompletionType string

type Constants struct {
	// Data represents the generic structure of the constants value
	// +optional
	Data ConstantsData `json:",omitempty"`
}

type ConstantsData map[string]json.RawMessage

type ContinueAs struct {
	// Unique id of the workflow to continue execution as.
	// +kubebuilder:validation:Required
	WorkflowID string `json:"workflowId" validate:"required"`
	// Version of the workflow to continue execution as.
	// +optional
	Version string `json:"version,omitempty"`
	// If string type, an expression which selects parts of the states data output to become the workflow data input of
	// continued execution. If object type, a custom object to become the workflow data input of the continued execution
	// +optional
	Data Object `json:"data,omitempty"`
	// WorkflowExecTimeout Workflow execution timeout to be used by the workflow continuing execution.
	// Overwrites any specific settings set by that workflow
	// +optional
	WorkflowExecTimeout WorkflowExecTimeout `json:"workflowExecTimeout,omitempty"`
}

type Correlation struct {
	// CloudEvent Extension Context Attribute name
	// +kubebuilder:validation:Required
	ContextAttributeName string `json:"contextAttributeName" validate:"required"`
	// CloudEvent Extension Context Attribute value
	// +optional
	ContextAttributeValue string `json:"contextAttributeValue,omitempty"`
}

type Cron struct {
	// Cron expression describing when the workflow instance should be created (automatically).
	// +kubebuilder:validation:Required
	Expression string `json:"expression" validate:"required"`
	// Specific date and time (ISO 8601 format) when the cron expression is no longer valid.
	// +optional
	ValidUntil string `json:"validUntil,omitempty" validate:"omitempty,iso8601datetime"`
}

type DataCondition struct {
	// Data condition name.
	// +optional
	Name string `json:"name,omitempty"`
	// Workflow expression evaluated against state data. Must evaluate to true or false.
	// +kubebuilder:validation:Required
	Condition string `json:"condition" validate:"required"`
	// Metadata information.
	// +optional
	Metadata Metadata `json:"metadata,omitempty"`
	// TODO End or Transition needs to be exclusive tag, one or another should be set.
	// Explicit transition to end
	End *End `json:"end" validate:"omitempty"`
	// Workflow transition if condition is evaluated to true
	Transition *Transition `json:"transition,omitempty" validate:"omitempty"`
}

type DataInputSchema struct {
	// +kubebuilder:validation:Required
	Schema string `json:"schema" validate:"required"`
	// +kubebuilder:validation:Required
	FailOnValidationErrors bool `json:"failOnValidationErrors"`
}

type DefaultCondition struct {
	// Serverless workflow states can have one or more incoming and outgoing transitions (from/to other states).
	// Each state can define a transition definition that is used to determine which state to transition to next.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Transition *Transition `json:"transition,omitempty"`
	// 	If this state an end state
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	End *End `json:"end,omitempty"`
}

type DelayState struct {
	// Amount of time (ISO 8601 format) to delay
	// +kubebuilder:validation:Required
	TimeDelay string `json:"timeDelay" validate:"required,iso8601duration"`
}

type End struct {
	// If true, completes all execution flows in the given workflow instance.
	// +optional
	Terminate bool `json:"terminate,omitempty"`
	// Array of producedEvent definitions. Defines events that should be produced.
	// +optional
	ProduceEvents []ProduceEvent `json:"produceEvents,omitempty"`
	// If set to true, triggers workflow compensation before workflow execution completes. Default is false.
	// +optional
	Compensate bool `json:"compensate,omitempty"`
	// Defines that current workflow execution should stop, and execution should continue as a new workflow
	// instance of the provided id
	// +optional
	ContinueAs *ContinueAs `json:"continueAs,omitempty"`
}

type Error struct {
	// Name Domain-specific error name.
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// Code OnError code. Can be used in addition to the name to help runtimes resolve to technical errors/exceptions.
	// Should not be defined if error is set to '*'.
	// +optional
	Code string `json:"code,omitempty" validate:"omitempty,min=1"`
	// OnError description.
	// +optional
	Description string `json:"description,omitempty"`
}

type Errors []Error

type Event struct {
	Common `json:",inline"`
	// Unique event name.
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// CloudEvent source.
	// +optional
	Source string `json:"source,omitempty"`
	// CloudEvent type.
	// +kubebuilder:validation:Required
	Type string `json:"type" validate:"required"`
	// Defines the CloudEvent as either 'consumed' or 'produced' by the workflow. Defaults to `consumed`.
	// +kubebuilder:validation:Enum=consumed;produced
	// +kubebuilder:default=consumed
	Kind EventKind `json:"kind,omitempty" validate:"required,oneofkind"`
	// If `true`, only the Event payload is accessible to consuming Workflow states. If `false`, both event payload
	// and context attributes should be accessible. Defaults to true.
	// +optional
	DataOnly bool `json:"dataOnly,omitempty"`
	// Define event correlation rules for this event. Only used for consumed events.
	// +optional
	Correlation []Correlation `json:"correlation,omitempty" validate:"dive"`
}

type EventCondition struct {
	// Event condition name.
	// +optional
	Name string `json:"name,omitempty"`
	// References a unique event name in the defined workflow events.
	// +kubebuilder:validation:Required
	EventRef string `json:"eventRef" validate:"required"`
	// Event data filter definition.
	// +optional
	EventDataFilter *EventDataFilter `json:"eventDataFilter,omitempty"`
	// Metadata information.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Metadata Metadata `json:"metadata,omitempty"`
	// TODO End or Transition needs to be exclusive tag, one or another should be set.
	// Explicit transition to end
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	End *End `json:"end" validate:"omitempty"`
	// Workflow transition if condition is evaluated to true
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Transition *Transition `json:"transition" validate:"omitempty"`
}

type EventConditions []EventCondition

type EventDataFilter struct {
	// If set to false, event payload is not added/merged to state data. In this case 'data' and 'toStateData'
	// should be ignored. Default is true.
	// +optional
	UseData bool `json:"useData,omitempty"`
	// Workflow expression that filters of the event data (payload).
	// +optional
	Data string `json:"data,omitempty"`
	// Workflow expression that selects a state data element to which the action results should be added/merged into.
	// If not specified denotes the top-level state data element
	// +optional
	ToStateData string `json:"toStateData,omitempty"`
}

type EventKind string

type EventRef struct {
	// Reference to the unique name of a 'produced' event definition,
	// +kubebuilder:validation:Required
	TriggerEventRef string `json:"triggerEventRef" validate:"required"`
	// Reference to the unique name of a 'consumed' event definition
	// +kubebuilder:validation:Required
	ResultEventRef string `json:"resultEventRef" validate:"required"`
	// Maximum amount of time (ISO 8601 format) to wait for the result event. If not defined it be set to the
	// actionExecutionTimeout
	// +optional
	ResultEventTimeout string `json:"resultEventTimeout,omitempty" validate:"omitempty,iso8601duration"`
	// If string type, an expression which selects parts of the states data output to become the data (payload)
	// of the event referenced by triggerEventRef. If object type, a custom object to become the data (payload)
	// of the event referenced by triggerEventRef.
	// +optional
	Data *Object `json:"data,omitempty"`
	// Add additional extension context attributes to the produced event.
	// +optional
	ContextAttributes map[string]Object `json:"contextAttributes,omitempty"`
	// Specifies if the function should be invoked sync or async. Default is sync.
	// +kubebuilder:validation:Enum=async;sync
	// +kubebuilder:default=sync
	Invoke InvokeKind `json:"invoke,omitempty" validate:"required,oneofkind"`
}

type EventState struct {

	// If true consuming one of the defined events causes its associated actions to be performed. If false all
	// the defined events must be consumed in order for actions to be performed. Defaults to true.
	// +kubebuilder:default=true
	// +optional
	Exclusive bool `json:"exclusive,omitempty"`
	// Define the events to be consumed and optional actions to be performed.
	// +kubebuilder:validation:MinItems=1
	OnEvents []OnEvents `json:"onEvents" validate:"required,min=1,dive"`
	// State specific timeouts.
	// +optional
	Timeouts *EventStateTimeout `json:"timeouts,omitempty"`
}

type EventStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Default single actions definition execution timeout (ISO 8601 duration format)
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
	// Default timeout for consuming defined events (ISO 8601 duration format)
	// +optional
	EventTimeout string `json:"eventTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type Events []Event

type ExpressionLangType string

type ForEachModeType string

type ForEachState struct {
	// Workflow expression selecting an array element of the states' data.
	// +kubebuilder:validation:Required
	InputCollection string `json:"inputCollection" validate:"required"`
	// Workflow expression specifying an array element of the states data to add the results of each iteration.
	// +optional
	OutputCollection string `json:"outputCollection,omitempty"`
	// Name of the iteration parameter that can be referenced in actions/workflow. For each parallel iteration,
	// this param should contain a unique element of the inputCollection array.
	// +optional
	IterationParam string `json:"iterationParam,omitempty"`
	// Specifies how many iterations may run in parallel at the same time. Used if mode property is set to
	// parallel (default). If not specified, its value should be the size of the inputCollection.
	// +optional
	BatchSize *intstr.IntOrString `json:"batchSize,omitempty"`
	// Actions to be executed for each of the elements of inputCollection.
	// +kubebuilder:validation:MinItems=0
	Actions []Action `json:"actions,omitempty" validate:"required,min=0,dive"`
	// State specific timeout.
	// +optional
	Timeouts *ForEachStateTimeout `json:"timeouts,omitempty"`
	// Specifies how iterations are to be performed (sequential or in parallel), defaults to parallel.
	// +kubebuilder:validation:Enum=sequential;parallel
	// +kubebuilder:default=parallel
	Mode ForEachModeType `json:"mode,omitempty" validate:"required,oneofkind"`
}

type ForEachStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Default single actions definition execution timeout (ISO 8601 duration format)
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type Function struct {
	Common `json:",inline"`
	// Unique function name
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// If type is `rest`, <path_to_openapi_definition>#<operation_id>.
	// If type is `rpc`, <path_to_grpc_proto_file>#<service_name>#<service_method>.
	// If type is `expression`, defines the workflow expression. If the type is `custom`,
	// <path_to_custom_script>#<custom_service_method>.
	// +kubebuilder:validation:Required
	Operation string `json:"operation" validate:"required"`
	// Defines the function type. Is either `custom`, `rest`, `rpc`, `expression`, `graphql`, `odata` or `asyncapi`.
	// Default is `rest`.
	// +kubebuilder:validation:Enum=rest;rpc;expression;graphql;odata;asyncapi;custom
	// +kubebuilder:default=rest
	Type FunctionType `json:"type,omitempty" validate:"required,oneofkind"`
	// References an auth definition name to be used to access to resource defined in the operation parameter.
	// +optional
	AuthRef string `json:"authRef,omitempty"`
}

type FunctionRef struct {
	// Name of the referenced function.
	// +kubebuilder:validation:Required
	RefName string `json:"refName" validate:"required"`
	// Arguments (inputs) to be passed to the referenced function
	// +optional
	// TODO: validate it as required if function type is graphql
	Arguments map[string]Object `json:"arguments,omitempty"`
	// Used if function type is graphql. String containing a valid GraphQL selection set.
	// TODO: validate it as required if function type is graphql
	// +optional
	SelectionSet string `json:"selectionSet,omitempty"`
	// Specifies if the function should be invoked sync or async. Default is sync.
	// +kubebuilder:validation:Enum=async;sync
	// +kubebuilder:default=sync
	Invoke InvokeKind `json:"invoke,omitempty" validate:"required,oneofkind"`
}

type FunctionType string

type Functions []Function

type GrantType string

type InjectState struct {
	// JSON object which can be set as state's data input and can be manipulated via filter
	// +kubebuilder:validation:MinProperties=1
	Data map[string]Object `json:"data" validate:"required,min=1"`
	// State specific timeouts
	// +optional
	Timeouts *InjectStateTimeout `json:"timeouts,omitempty"`
}

type InjectStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
}

type InvokeKind string

type Metadata map[string]Object

type OAuth2AuthProperties struct {
	Common `json:",inline"`
	// Expression referencing a workflow secret that contains all needed auth info.
	// +optional
	Secret string `json:"secret,omitempty"`
	// String or a workflow expression. Contains the authority information.
	// +optional
	Authority string `json:"authority,omitempty" validate:"omitempty,min=1"`
	// 	Defines the grant type. Can be "password", "clientCredentials", or "tokenExchange"
	// +kubebuilder:validation:Enum=password;clientCredentials;tokenExchange
	// +kubebuilder:validation:Required
	GrantType GrantType `json:"grantType" validate:"required,oneofkind"`
	// String or a workflow expression. Contains the client identifier.
	// +kubebuilder:validation:Required
	ClientID string `json:"clientId" validate:"required"`
	// Workflow secret or a workflow expression. Contains the client secret.
	// +optional
	ClientSecret string `json:"clientSecret,omitempty" validate:"omitempty,min=1"`
	// Array containing strings or workflow expressions. Contains the OAuth2 scopes.
	// +optional
	Scopes []string `json:"scopes,omitempty" validate:"omitempty,min=1"`
	// String or a workflow expression. Contains the username. Used only if grantType is 'resourceOwner'.
	// +optional
	Username string `json:"username,omitempty" validate:"omitempty,min=1"`
	// String or a workflow expression. Contains the user password. Used only if grantType is 'resourceOwner'.
	// +optional
	Password string `json:"password,omitempty" validate:"omitempty,min=1"`
	// Array containing strings or workflow expressions. Contains the OAuth2 audiences.
	// +optional
	Audiences []string `json:"audiences,omitempty" validate:"omitempty,min=1"`
	// String or a workflow expression. Contains the subject token.
	// +optional
	SubjectToken string `json:"subjectToken,omitempty" validate:"omitempty,min=1"`
	// String or a workflow expression. Contains the requested subject.
	// +optional
	RequestedSubject string `json:"requestedSubject,omitempty" validate:"omitempty,min=1"`
	// String or a workflow expression. Contains the requested issuer.
	// +optional
	RequestedIssuer string `json:"requestedIssuer,omitempty" validate:"omitempty,min=1"`
}

type Object struct {
	Type        Type   `json:"type,inline"`
	StringValue string `json:"strVal,inline"`
	IntValue    int32  `json:"intVal,inline"`
	FloatValue  float64
	MapValue    map[string]Object
	SliceValue  []Object
	BoolValue   bool `json:"boolValue,inline"`
}

type OnError struct {
	// ErrorRef Reference to a unique workflow error definition. Used of errorRefs is not used
	ErrorRef string `json:"errorRef,omitempty"`
	// ErrorRefs References one or more workflow error definitions. Used if errorRef is not used
	ErrorRefs []string `json:"errorRefs,omitempty" validate:"omitempty,unique"`
	// Transition to next state to handle the error. If retryRef is defined, this transition is taken only if
	// retries were unsuccessful.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	Transition *Transition `json:"transition,omitempty"`
	// End workflow execution in case of this error. If retryRef is defined, this ends workflow only if
	// retries were unsuccessful.
	// +kubebuilder:validation:Schemaless
	// +kubebuilder:pruning:PreserveUnknownFields
	// +optional
	End *End `json:"end,omitempty"`
}

type OnEvents struct {
	// References one or more unique event names in the defined workflow events.
	// +kubebuilder:validation:MinItems=1
	EventRefs []string `json:"eventRefs" validate:"required,min=1"`
	// Should actions be performed sequentially or in parallel. Default is sequential.
	// +kubebuilder:validation:Enum=sequential;parallel
	// +kubebuilder:default=sequential
	ActionMode ActionMode `json:"actionMode,omitempty" validate:"required,oneofkind"`
	// Actions to be performed if expression matches
	// +optional
	Actions []Action `json:"actions,omitempty" validate:"dive"`
	// eventDataFilter defines the callback event data filter definition
	// +optional
	EventDataFilter EventDataFilter `json:"eventDataFilter,omitempty"`
}

type OnParentCompleteType string

type OperationState struct {
	// Specifies whether actions are performed in sequence or in parallel, defaults to sequential.
	// +kubebuilder:validation:Enum=sequential;parallel
	// +kubebuilder:default=sequential
	ActionMode ActionMode `json:"actionMode,omitempty" validate:"required,oneofkind"`
	// Actions to be performed
	// +kubebuilder:validation:MinItems=0
	Actions []Action `json:"actions" validate:"min=0,dive"`
	// State specific timeouts
	// +optional
	Timeouts *OperationStateTimeout `json:"timeouts,omitempty"`
}

type OperationStateTimeout struct {
	// Defines workflow state execution timeout.
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Default single actions definition execution timeout (ISO 8601 duration format)
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type ParallelState struct {
	// List of branches for this parallel state.
	// +kubebuilder:validation:MinItems=1
	Branches []Branch `json:"branches" validate:"required,min=1,dive"`
	// Option types on how to complete branch execution. Defaults to `allOf`.
	// +kubebuilder:validation:Enum=allOf;atLeast
	// +kubebuilder:default=allOf
	CompletionType CompletionType `json:"completionType,omitempty" validate:"required,oneofkind"`
	// Used when branchCompletionType is set to atLeast to specify the least number of branches that must complete
	// in order for the state to transition/end.
	// +optional
	// TODO: change this field to unmarshal result as int
	NumCompleted intstr.IntOrString `json:"numCompleted,omitempty"`
	// State specific timeouts
	// +optional
	Timeouts *ParallelStateTimeout `json:"timeouts,omitempty"`
}

type ParallelStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Default single branch execution timeout (ISO 8601 duration format)
	// +optional
	BranchExecTimeout string `json:"branchExecTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type ProduceEvent struct {
	// Reference to a defined unique event name in the events definition
	// +kubebuilder:validation:Required
	EventRef string `json:"eventRef" validate:"required"`
	// If String, expression which selects parts of the states data output to become the data of the produced event.
	// If object a custom object to become the data of produced event.
	// +optional
	Data Object `json:"data,omitempty"`
	// Add additional event extension context attributes.
	// +optional
	ContextAttributes map[string]string `json:"contextAttributes,omitempty"`
}

type Retries []Retry

type Retry struct {
	// Unique retry strategy name
	// +kubebuilder:validation:Required
	Name string `json:"name" validate:"required"`
	// Time delay between retry attempts (ISO 8601 duration format)
	Delay string `json:"delay,omitempty" validate:"omitempty,iso8601duration"`
	// Maximum time delay between retry attempts (ISO 8601 duration format)
	MaxDelay string `json:"maxDelay,omitempty" validate:"omitempty,iso8601duration"`
	// Static value by which the delay increases during each attempt (ISO 8601 time format)
	Increment string `json:"increment,omitempty" validate:"omitempty,iso8601duration"`
	// Numeric value, if specified the delay between retries is multiplied by this value.
	// +optional
	Multiplier *floatstr.Float32OrString `json:"multiplier,omitempty" validate:"omitempty,min=1"`
	// Maximum number of retry attempts.
	// +kubebuilder:validation:Required
	MaxAttempts intstr.IntOrString `json:"maxAttempts" validate:"required"`
	// If float type, maximum amount of random time added or subtracted from the delay between each retry relative to total delay (between 0 and 1). If string type, absolute maximum amount of random time added or subtracted from the delay between each retry (ISO 8601 duration format)
	// TODO: make iso8601duration compatible this type
	Jitter floatstr.Float32OrString `json:"jitter,omitempty" validate:"omitempty,min=0,max=1"`
}

type Schedule struct {
	// TODO Interval is required if Cron is not set and vice-versa, make a exclusive validation
	// A recurring time interval expressed in the derivative of ISO 8601 format specified below. Declares that
	// workflow instances should be automatically created at the start of each time interval in the series.
	// +optional
	Interval string `json:"interval,omitempty"`
	// Cron expression defining when workflow instances should be automatically created.
	// optional
	Cron *Cron `json:"cron,omitempty"`
	// Timezone name used to evaluate the interval & cron-expression. If the interval specifies a date-time
	// w/ timezone then proper timezone conversion will be applied. (default: UTC).
	// +optional
	Timezone string `json:"timezone,omitempty"`
}

type Secrets []string

type Sleep struct {
	// Defines amount of time (ISO 8601 duration format) to sleep before function/subflow invocation.
	// Does not apply if 'eventRef' is defined.
	// +optional
	Before string `json:"before,omitempty" validate:"omitempty,iso8601duration"`
	// Defines amount of time (ISO 8601 duration format) to sleep after function/subflow invocation.
	// Does not apply if 'eventRef' is defined.
	// +optional
	After string `json:"after,omitempty" validate:"omitempty,iso8601duration"`
}

type SleepState struct {
	// Duration (ISO 8601 duration format) to sleep
	// +kubebuilder:validation:Required
	Duration string `json:"duration" validate:"required,iso8601duration"`
	// Timeouts State specific timeouts
	// +optional
	Timeouts *SleepStateTimeout `json:"timeouts,omitempty"`
}

type SleepStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
}

type Start struct {
	// Name of the starting workflow state
	// +kubebuilder:validation:Required
	StateName string `json:"stateName" validate:"required"`
	// Define the recurring time intervals or cron expressions at which workflow instances should be automatically
	// started.
	// +optional
	Schedule *Schedule `json:"schedule,omitempty" validate:"omitempty"`
}

type State struct {
	BaseState `json:",inline"`
	// delayState Causes the workflow execution to delay for a specified duration.
	// +optional
	*DelayState `json:"delayState,omitempty"`
	// event states await one or more events and perform actions when they are received. If defined as the
	// workflow starting state, the event state definition controls when the workflow instances should be created.
	// +optional
	*EventState `json:"eventState,omitempty"`
	// operationState defines a set of actions to be performed in sequence or in parallel.
	// +optional
	*OperationState `json:"operationState,omitempty"`
	// parallelState Consists of a number of states that are executed in parallel.
	// +optional
	*ParallelState `json:"parallelState,omitempty"`
	// switchState is workflow's gateways: direct transitions onf a workflow based on certain conditions.
	// +optional
	*SwitchState `json:"switchState,omitempty"`
	// forEachState used to execute actions for each element of a data set.
	// +optional
	*ForEachState `json:"forEachState,omitempty"`
	// injectState used to inject static data into state data input.
	// +optional
	*InjectState `json:"injectState,omitempty"`
	// callbackState executes a function and waits for callback event that indicates completion of the task.
	// +optional
	*CallbackState `json:"callbackState,omitempty"`
	// sleepState suspends workflow execution for a given time duration.
	// +optional
	*SleepState `json:"sleepState,omitempty"`
}

type StateDataFilter struct {
	// Workflow expression to filter the state data input
	Input string `json:"input,omitempty"`
	// Workflow expression that filters the state data output
	Output string `json:"output,omitempty"`
}

type StateExecTimeout struct {
	// Single state execution timeout, not including retries (ISO 8601 duration format)
	// +optional
	Single string `json:"single,omitempty" validate:"omitempty,iso8601duration"`
	// Total state execution timeout, including retries (ISO 8601 duration format)
	// +kubebuilder:validation:Required
	Total string `json:"total" validate:"required,iso8601duration"`
}

type StateType string

type States []State

type SwitchState struct {

	// Default transition of the workflow if there is no matching data conditions. Can include a transition or
	// end definition.
	DefaultCondition DefaultCondition `json:"defaultCondition"`
	// Defines conditions evaluated against events.
	// +optional
	EventConditions EventConditions `json:"eventConditions" validate:"dive"`
	// Defines conditions evaluated against data
	// +optional
	DataConditions []DataCondition `json:"dataConditions" validate:"dive"`
	// SwitchState specific timeouts
	// +optional
	Timeouts *SwitchStateTimeout `json:"timeouts,omitempty"`
}

type SwitchStateTimeout struct {
	// Default workflow state execution timeout (ISO 8601 duration format)
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// Specify the expire value to transitions to defaultCondition. When event-based conditions do not arrive.
	// NOTE: this is only available for EventConditions
	// +optional
	EventTimeout string `json:"eventTimeout,omitempty" validate:"omitempty,iso8601duration"`
}

type Timeouts struct {
	// WorkflowExecTimeout Workflow execution timeout duration (ISO 8601 duration format). If not specified should
	// be 'unlimited'.
	// +optional
	WorkflowExecTimeout *WorkflowExecTimeout `json:"workflowExecTimeout,omitempty"`
	// StateExecTimeout Total state execution timeout (including retries) (ISO 8601 duration format).
	// +optional
	StateExecTimeout *StateExecTimeout `json:"stateExecTimeout,omitempty"`
	// ActionExecTimeout Single actions definition execution timeout duration (ISO 8601 duration format).
	// +optional
	ActionExecTimeout string `json:"actionExecTimeout,omitempty" validate:"omitempty,min=1"`
	// BranchExecTimeout Single branch execution timeout duration (ISO 8601 duration format).
	// +optional
	BranchExecTimeout string `json:"branchExecTimeout,omitempty" validate:"omitempty,min=1"`
	// EventTimeout Timeout duration to wait for consuming defined events (ISO 8601 duration format).
	// +optional
	EventTimeout string `json:"eventTimeout,omitempty" validate:"omitempty,min=1"`
}

type Transition struct {

	// Name of the state to transition to next.
	// +kubebuilder:validation:Required
	NextState string `json:"nextState" validate:"required,min=1"`
	// Array of producedEvent definitions. Events to be produced before the transition takes place.
	// +optional
	ProduceEvents []ProduceEvent `json:"produceEvents,omitempty" validate:"omitempty,dive"`
	// If set to true, triggers workflow compensation before this transition is taken. Default is false.
	// +kubebuilder:default=false
	// +optional
	Compensate bool `json:"compensate,omitempty"`
	// contains filtered or unexported fields
}

type Type int8

type ValidatorContext struct {
	States    map[string]State
	Functions map[string]Function
	Events    map[string]Event
	Retries   map[string]Retry
	Errors    map[string]Error
}

type Workflow struct {
	BaseWorkflow `json:",inline"`
	// +kubebuilder:pruning:PreserveUnknownFields
	States States `json:"states" validate:"min=1,unique=Name,dive"`
	// +optional
	Events Events `json:"events,omitempty" validate:"unique=Name,dive"`
	// +optional
	Functions Functions `json:"functions,omitempty" validate:"unique=Name,dive"`
	// +optional
	Retries Retries `json:"retries,omitempty" validate:"unique=Name,dive"`
}

type WorkflowExecTimeout struct {
	// Workflow execution timeout duration (ISO 8601 duration format). If not specified should be 'unlimited'.
	// +kubebuilder:default=unlimited
	Duration string `json:"duration" validate:"required,min=1,iso8601duration"`
	// If false, workflow instance is allowed to finish current execution. If true, current workflow execution
	// is stopped immediately. Default is false.
	// +optional
	Interrupt bool `json:"interrupt,omitempty"`
	// Name of a workflow state to be executed before workflow instance is terminated.
	// +optional
	RunBefore string `json:"runBefore,omitempty" validate:"omitempty,min=1"`
}

type WorkflowRef struct {
	// Sub-workflow unique id
	// +kubebuilder:validation:Required
	WorkflowID string `json:"workflowId" validate:"required"`
	// Sub-workflow version
	// +optional
	Version string `json:"version,omitempty"`
	// Specifies if the subflow should be invoked sync or async.
	// Defaults to sync.
	// +kubebuilder:validation:Enum=async;sync
	// +kubebuilder:default=sync
	// +optional
	Invoke InvokeKind `json:"invoke,omitempty" validate:"required,oneofkind"`
	// onParentComplete specifies how subflow execution should behave when parent workflow completes if invoke
	// is 'async'. Defaults to terminate.
	// +kubebuilder:validation:Enum=terminate;continue
	// +kubebuilder:default=terminate
	OnParentComplete OnParentCompleteType `json:"onParentComplete,omitempty" validate:"required,oneofkind"`
}

type WorkflowValidator func(mapValues ValidatorContext, sl validator.StructLevel)