core

type APITriggerCriteria struct {
	// Enabled determines if the API trigger is active
	Enabled bool `json:"enabled"`

	// Endpoint is the API endpoint path
	Endpoint string `json:"endpoint,omitempty"`

	// Method is the HTTP method for the API endpoint
	Method string `json:"method,omitempty"`

	// Authentication determines if authentication is required
	Authentication bool `json:"authentication"`

	// RequiredScope is the required OAuth scope
	RequiredScope string `json:"requiredScope,omitempty"`

	// InputSchema defines the expected input schema
	InputSchema *smartform.FormSchema `json:"inputSchema,omitempty"`

	// RateLimit is the maximum number of requests per minute
	RateLimit int `json:"rateLimit,omitempty"`
}

type ActionSettings struct {
	// Loop *LoopSettings `json:"loop,omitempty"`
	Branch   *BranchSettings   `json:"_"`
	Router   *RouterSettings   `json:"router,omitempty"`
	Parallel *ParallelSettings `json:"parallel,omitempty"`
}

type ActionType string

type AuthMetadata struct {
	// Type of authentication (oauth2, api_key, basic, etc.)
	Type     AuthType              `json:"type"`
	Schema   *smartform.FormSchema `json:"schema"`
	Required bool                  `json:"required"`
	Inherit  bool                  `json:"inherit"`
}

type AuthType string

type BranchSettings struct {
	// DefaultBranch specifies which branch to follow when no condition is met
	DefaultBranch string `json:"defaultBranch,omitempty"`

	// EvaluateAll determines if all branch conditions should be evaluated
	// or only until the first match
	EvaluateAll bool `json:"evaluateAll,omitempty"`

	// Expression is a JavaScript expression that determines which branch to take
	Expression string `json:"expression,omitempty"`

	// ExpressionEngine defines which engine to use for expression evaluation
	// Default is "javascript"
	ExpressionEngine string `json:"expressionEngine,omitempty"`

	// ConditionField is the specific field to evaluate in the step's output
	ConditionField string `json:"conditionField,omitempty"`

	// ConditionOperator defines how to compare the field value (equals, contains, etc.)
	ConditionOperator string `json:"conditionOperator,omitempty"`

	// ConditionValue is the value to compare against
	ConditionValue interface{} `json:"conditionValue,omitempty"`

	// AllowMultiPath determines if multiple branches can be activated simultaneously
	AllowMultiPath bool `json:"allowMultiPath,omitempty"`

	// BranchMode defines how branches are evaluated (expression, condition, or value)
	BranchMode RouteMode `json:"branchMode,omitempty"`

	// Branches defines the specific branches available
	Branches []FlowRouter `json:"branches,omitempty"`
}

type DynamicOptionsFilterParams struct {
	Offset     int    `json:"offset"` // The offset of the first item to return (default: 0)
	Limit      int    `json:"limit"`  // The maximum number of items to return (default: 10)
	FilterTerm string `json:"filterTerm"`
}

type DynamicOptionsResponse struct {
	Metadata OffsetPaginationMeta `json:"metadata"`
	Items    any                  `json:"items"`
}

type Environment string

type EventTriggerCriteria struct {
	// EventName specifies the name of the event to subscribe to
	EventName string `json:"eventName" validate:"required"`

	// Source specifies the source of the event
	Source string `json:"source" validate:"required"`

	// Filters allow refining event criteria
	Filters map[string]any `json:"filters,omitempty"`

	// EventPattern is a pattern to match against the event
	EventPattern string `json:"eventPattern,omitempty"`

	// MaxEvents is the maximum number of events to process at once
	MaxEvents int `json:"maxEvents,omitempty"`

	// Deduplicate determines if duplicate events should be filtered
	Deduplicate bool `json:"deduplicate"`

	// Batching determines if events should be batched
	Batching bool `json:"batching"`

	// BatchSize is the number of events to include in a batch
	BatchSize int `json:"batchSize,omitempty"`

	// BatchWindow is the time window for event batching
	BatchWindow string `json:"batchWindow,omitempty"`
}

type FlowComponentType string

type FlowRouter struct {
	// ID is the unique identifier of the branch
	ID string `json:"id,omitempty"`

	// Name is the display name of the branch
	Name string `json:"name,omitempty"`

	// Condition is the condition expression for this branch
	Condition any `json:"condition,omitempty"`

	// Value is the expected value for this branch
	// (used with RouteModeValue)
	Value interface{} `json:"value,omitempty"`

	// Order determines the evaluation order of branches
	Order int `json:"order,omitempty"`

	// NextStep is the ID of the step to execute if this branch is selected
	NextStep string `json:"nextStep,omitempty"`

	// IsDefault indicates if this is the default branch
	IsDefault bool `json:"isDefault,omitempty"`

	// ConditionField is the specific field to evaluate for this branch
	ConditionField string `json:"conditionField,omitempty"`

	// ConditionOperator defines how to compare values for this branch
	ConditionOperator string `json:"conditionOperator,omitempty"`

	// ConditionValue is the value to compare against for this branch
	ConditionValue interface{} `json:"conditionValue,omitempty"`

	// Description is the description of the branch
	Description string `json:"description,omitempty"`
}

type IntegrationBuildMetadata struct {
	Platform IntegrationPlatform `json:"compiler"`
	Language IntegrationLanguage `json:"language,omitempty"`
}

type IntegrationLanguage string

type IntegrationPlatform string

type JSON interface{}

type JSONObject = map[string]any

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

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

type LogEntry struct {
	Timestamp time.Time `json:"timestamp"` // Timestamp of the log
	Level     LogLevel  `json:"level"`     // Severity level of the log
	Message   string    `json:"message"`   // Log message itself
}

type LogLevel string

type LogLine struct {
	// ID of the ent.
	ID xid.ID `json:"id,omitempty"`
	// CreatedAt holds the value of the "created_at" field.
	CreatedAt time.Time `json:"created_at,omitempty"`
	// ProjectID holds the value of the "team_id" field.
	ProjectID xid.ID `json:"project_id,omitempty"`
	// StepRunID holds the value of the "step_run_id" field.
	StepRunID *string `json:"step_run_id,omitempty"`
	// FlowID holds the value of the "step_run_id" field.
	FlowID *string `json:"flow_id,omitempty"`
	// Message holds the value of the "message" field.
	Message string `json:"message,omitempty"`
	// Level holds the value of the "level" field.
	Level LogLineLevel `json:"level,omitempty"`
	// Metadata holds the value of the "metadata" field.
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type LogLineLevel string

type LogSink interface {
	Write(ctx context.Context, logEntry LogEntry) error // Write a log entry to the sink
}

type Logger interface {
	AddLog(level LogLevel, message string, a ...any)
	SetPrefix(prefix string)
	GetLogs() []LogEntry
	ClearLogs()
	Info(message string, keysAndValues ...interface{})
	Infof(message string, a ...any)
	Warn(message string, keysAndValues ...interface{})
	Warnf(message string, a ...any)
	Error(message string, keysAndValues ...interface{})
	Errorf(err error, message string, a ...any)
	Debug(message string, keysAndValues ...interface{})
	Debugf(message string, a ...any)
	WithField(key string, value interface{}) Logger
	WithFields(fields map[string]interface{}) Logger
	Clone() Logger
}

type ManualTriggerCriteria struct {
	// Description is an optional field to describe the purpose of the manual trigger
	Description string `json:"description,omitempty"`

	// UserInputSchema defines a schema for the input required when triggering manually
	UserInputSchema *smartform.FormSchema `json:"userInputSchema,omitempty"`

	// RequireApproval specifies if the manual trigger requires prior approval to execute
	RequireApproval bool `json:"requireApproval"`

	// ExecutionTimeout defines the maximum allowed time for the manual step to be completed
	ExecutionTimeout *time.Duration `json:"executionTimeout,omitempty"`

	// Approvers is a list of users who can approve the trigger
	Approvers []string `json:"approvers,omitempty"`

	// ApproverGroups is a list of groups who can approve the trigger
	ApproverGroups []string `json:"approverGroups,omitempty"`

	// Tags provide searchable metadata for this trigger
	Tags []string `json:"tags,omitempty"`

	// ShowInUI determines if this trigger should be visible in the UI
	ShowInUI bool `json:"showInUI"`

	// ButtonLabel is the text to display on the trigger button
	ButtonLabel string `json:"buttonLabel,omitempty"`

	// ButtonIcon is the icon to display on the trigger button
	ButtonIcon string `json:"buttonIcon,omitempty"`
}

type MessageTriggerCriteria struct {
	// MessageType is the type of message that triggers the workflow
	MessageType string `json:"messageType,omitempty"`

	// Source is the source of the message
	Source string `json:"source,omitempty"`

	// Destination is the destination of the message
	Destination string `json:"destination,omitempty"`

	// Filter is a filter expression applied to the message
	Filter string `json:"filter,omitempty"`

	// Enabled determines if the message trigger is active
	Enabled bool `json:"enabled"`
}

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

type OffsetPaginationMeta struct {
	Offset     int  `json:"offset"`
	Limit      int  `json:"limit"`
	TotalItems int  `json:"totalItems"`
	HasMore    bool `json:"hasMore"`
}

type ParallelBranch struct {
	// ID is the unique identifier of the branch
	ID string `json:"id,omitempty"`

	// Name is the display name of the branch
	Name string `json:"name,omitempty"`

	// Description describes the branch purpose
	Description string `json:"description,omitempty"`

	// Weight defines the relative importance/priority of this branch
	Weight int `json:"weight,omitempty"`

	// Condition is an optional condition that must be true to execute this branch
	Condition string `json:"condition,omitempty"`

	// NextStep is the ID of the step to execute in this branch
	NextStep string `json:"nextStep,omitempty"`

	// Timeout defines timeout specific to this branch
	Timeout *time.Duration `json:"timeout,omitempty"`

	// RetryPolicy defines retry behavior specific to this branch
	RetryPolicy *ParallelRetryPolicy `json:"retryPolicy,omitempty"`

	// Required indicates if this branch is required for overall success
	Required bool `json:"required,omitempty"`

	// Order defines execution order (for ordered parallel execution)
	Order int `json:"order,omitempty"`

	// ResourceRequirements defines resource needs for this branch
	ResourceRequirements map[string]interface{} `json:"resourceRequirements,omitempty"`

	// Tags for categorizing and filtering branches
	Tags []string `json:"tags,omitempty"`

	// Metadata for additional branch information
	Metadata map[string]interface{} `json:"metadata,omitempty"`
}

type ParallelCallback struct {
	// Expression to evaluate
	Expression string `json:"expression,omitempty"`

	// NextStep to execute
	NextStep string `json:"nextStep,omitempty"`

	// NotificationSettings for sending notifications
	NotificationSettings map[string]interface{} `json:"notificationSettings,omitempty"`
}

type ParallelErrorHandling string

type ParallelPriority string

type ParallelResultHandling string

type ParallelRetryPolicy struct {
	// MaxAttempts defines maximum retry attempts
	MaxAttempts int `json:"maxAttempts,omitempty"`

	// BackoffType defines the backoff strategy
	BackoffType string `json:"backoffType,omitempty"` // linear, exponential, fixed

	// InitialDelay is the initial delay before first retry
	InitialDelay time.Duration `json:"initialDelay,omitempty"`

	// MaxDelay is the maximum delay between retries
	MaxDelay time.Duration `json:"maxDelay,omitempty"`

	// BackoffMultiplier for exponential backoff
	BackoffMultiplier float64 `json:"backoffMultiplier,omitempty"`

	// RetriableErrors defines which errors should trigger a retry
	RetriableErrors []string `json:"retriableErrors,omitempty"`

	// NonRetriableErrors defines which errors should not trigger a retry
	NonRetriableErrors []string `json:"nonRetriableErrors,omitempty"`
}

type ParallelSettings struct {
	Type ParallelType `json:"type,omitempty"`

	// MaxConcurrency limits the maximum number of concurrent executions
	// 0 means unlimited (use with caution)
	MaxConcurrency int `json:"maxConcurrency,omitempty"`

	// BatchSize defines the number of branches to execute per batch (for batch type)
	BatchSize int `json:"batchSize,omitempty"`

	// ThrottleRate defines the rate limit for throttled execution (executions per second)
	ThrottleRate float64 `json:"throttleRate,omitempty"`

	// Timeout defines the maximum time to wait for all branches to complete
	Timeout *time.Duration `json:"timeout,omitempty"`

	// ErrorHandling defines how to handle errors during parallel execution
	ErrorHandling ParallelErrorHandling `json:"errorHandling,omitempty"`

	// ResultHandling defines how to aggregate and return results
	ResultHandling ParallelResultHandling `json:"resultHandling,omitempty"`

	// WaitForAll determines if we should wait for all branches to complete
	// (only applies to certain types)
	WaitForAll bool `json:"waitForAll,omitempty"`

	// FailOnError determines if the entire parallel execution should fail on any error
	FailOnError bool `json:"failOnError,omitempty"`

	// MinSuccessCount defines minimum successful branches required for overall success
	MinSuccessCount int `json:"minSuccessCount,omitempty"`

	// MaxFailureCount defines maximum failures allowed before stopping
	MaxFailureCount int `json:"maxFailureCount,omitempty"`

	// RetryPolicy defines retry behavior for failed branches
	RetryPolicy *ParallelRetryPolicy `json:"retryPolicy,omitempty"`

	// Priority defines execution priority for branches
	Priority ParallelPriority `json:"priority,omitempty"`

	// EnableLoadBalancing enables automatic load balancing across available resources
	EnableLoadBalancing bool `json:"enableLoadBalancing,omitempty"`

	// ResourceConstraints defines resource limits for parallel execution
	ResourceConstraints *ResourceConstraints `json:"resourceConstraints,omitempty"`

	// CollectMetrics determines if execution metrics should be collected
	CollectMetrics bool `json:"collectMetrics,omitempty"`

	// EnableTracing enables distributed tracing for parallel branches
	EnableTracing bool `json:"enableTracing,omitempty"`

	// BranchTimeout defines timeout for individual branches
	BranchTimeout *time.Duration `json:"branchTimeout,omitempty"`

	// Branches defines the parallel execution branches
	Branches []ParallelBranch `json:"branches,omitempty"`

	// PreCondition is an expression that must evaluate to true before parallel execution
	PreCondition string `json:"preCondition,omitempty"`

	// PostCondition is an expression to evaluate after parallel execution
	PostCondition string `json:"postCondition,omitempty"`

	// OnSuccess defines actions to take when parallel execution succeeds
	OnSuccess *ParallelCallback `json:"onSuccess,omitempty"`

	// OnFailure defines actions to take when parallel execution fails
	OnFailure *ParallelCallback `json:"onFailure,omitempty"`

	// OnPartialSuccess defines actions to take when some branches succeed
	OnPartialSuccess *ParallelCallback `json:"onPartialSuccess,omitempty"`
}

type ParallelType string

type PollingTriggerCriteria struct {
	// Interval defines the duration between each poll
	Interval time.Duration `json:"interval" validate:"required,gt=0"`

	// MinInterval defines the duration between each poll
	MinInterval time.Duration `json:"minInterval" validate:"required,gt=0"`

	// MaxInterval defines the duration between each poll
	MaxInterval time.Duration `json:"maxInterval" validate:"required,gt=0"`

	// MaxRetries specifies the maximum number of retries in case polling fails
	MaxRetries int `json:"maxRetries,omitempty" validate:"min=0"`

	// FetchLimit defines the maximum number of items to fetch per poll
	FetchLimit int `json:"fetchLimit,omitempty" validate:"min=1"`

	// DataFilters allows specifying conditions for the data being fetched
	DataFilters map[string]any `json:"dataFilters,omitempty"`

	// AllowEmptyData determines if polling should proceed without error when no data is returned
	AllowEmptyData bool `json:"allowEmptyData"`

	// LastExecutionTime holds the timestamp of the last successful poll
	LastExecutionTime *time.Time `json:"lastExecutionTime,omitempty"`

	// Enabled determines whether the polling trigger is active
	Enabled bool `json:"enabled" validate:"required"`

	// ExcludedDays allows specifying days when polling should be skipped
	ExcludedDays []time.Weekday `json:"excludedDays,omitempty"`

	// ExcludedHours allows specifying hours when polling should be skipped
	ExcludedHours []int `json:"excludedHours,omitempty"`

	// TimeoutSeconds is the maximum time allowed for a polling operation
	TimeoutSeconds int `json:"timeoutSeconds,omitempty"`

	// Deduplicate determines if duplicate items should be filtered
	Deduplicate bool `json:"deduplicate"`

	// DedupKeyPath is the path to the field used for deduplication
	DedupKeyPath string `json:"dedupKeyPath,omitempty"`
}

type ResourceConstraints struct {
	// MaxMemory defines maximum memory usage (in bytes)
	MaxMemory int64 `json:"maxMemory,omitempty"`

	// MaxCPU defines maximum CPU usage (as percentage)
	MaxCPU float64 `json:"maxCPU,omitempty"`

	// MaxDiskIO defines maximum disk I/O usage
	MaxDiskIO int64 `json:"maxDiskIO,omitempty"`

	// MaxNetworkIO defines maximum network I/O usage
	MaxNetworkIO int64 `json:"maxNetworkIO,omitempty"`

	// MaxExecutionTime defines maximum total execution time
	MaxExecutionTime *time.Duration `json:"maxExecutionTime,omitempty"`
}

type RetryPolicy struct {
	// Enabled determines if retry is enabled
	Enabled bool `json:"enabled" validate:"required"`

	// MaxRetries specifies the maximum number of retry attempts
	MaxRetries int `json:"maxRetries" validate:"min=0"`

	// RetryInterval defines the time to wait between retry attempts
	RetryInterval time.Duration `json:"retryInterval" validate:"gt=0"`

	BackoffFactor float64 `json:"backoffFactor"`

	// ExponentialBackoff determines if exponential backoff is used for retries
	ExponentialBackoff bool `json:"exponentialBackoff"`

	// MaxInterval is the maximum interval between retries when using exponential backoff
	MaxInterval time.Duration `json:"maxInterval,omitempty"`

	// RetryableErrors defines which errors should be retried
	RetryableErrors []string `json:"retryableErrors,omitempty"`
}

type RouteMode string

type RouterSettings struct {
	Type RouterType `json:"type,omitempty"`

	// DefaultRoute specifies which branch to follow when no condition is met
	DefaultRoute string `json:"defaultRoute,omitempty"`

	// EvaluateAll determines if all branch conditions should be evaluated
	// or only until the first match
	EvaluateAll bool `json:"evaluateAll,omitempty"`

	// Expression is a JavaScript expression that determines which branch to take
	Expression string `json:"expression,omitempty"`

	// ExpressionEngine defines which engine to use for expression evaluation
	// Default is "javascript"
	ExpressionEngine string `json:"expressionEngine,omitempty"`

	// ConditionField is the specific field to evaluate in the step's output
	ConditionField string `json:"conditionField,omitempty"`

	// ConditionOperator defines how to compare the field value (equals, contains, etc.)
	ConditionOperator string `json:"conditionOperator,omitempty"`

	// ConditionValue is the value to compare against
	ConditionValue interface{} `json:"conditionValue,omitempty"`

	// AllowMultiPath determines if multiple branches can be activated simultaneously
	AllowMultiPath bool `json:"allowMultiPath,omitempty"`

	// RouteMode defines how branches are evaluated (expression, condition, or value)
	RouteMode RouteMode `json:"routeMode,omitempty"`

	// Routes defines the specific branches available
	Routes []FlowRouter `json:"routes,omitempty"`
}

type RouterType string

type ScheduleTriggerCriteria struct {
	// CronExpression specifies the schedule using a cron expression
	CronExpression string `json:"cronExpression" validate:"required,cron"`

	// StartTime specifies the time to begin the schedule execution
	StartTime *time.Time `json:"startTime,omitempty"`

	// EndTime specifies the time to stop the schedule execution
	EndTime *time.Time `json:"endTime,omitempty"`

	// TimeZone allows defining the time zone for the cron schedule
	TimeZone string `json:"timeZone" validate:"required"`

	// Enabled determines if the schedule trigger is active
	Enabled bool `json:"enabled" validate:"required"`

	Interval *time.Duration `json:"interval,omitempty"`

	// MaxConcurrentRuns is the maximum number of concurrent runs
	MaxConcurrentRuns int `json:"maxConcurrentRuns,omitempty"`

	// SkipIfPreviousRunning determines if a run should be skipped if the previous one is still running
	SkipIfPreviousRunning bool `json:"skipIfPreviousRunning"`

	// MissedRunPolicy defines what to do with missed runs (skip, run-once, run-all)
	MissedRunPolicy string `json:"missedRunPolicy,omitempty"`

	// Description provides additional information about the schedule
	Description string `json:"description,omitempty"`
}

type StepRunStatus string

type SystemActivityLog struct {
	Level     LogLevel  `json:"level"`
	Scope     string    `json:"scope"`
	Message   string    `json:"message"`
	Timestamp time.Time `json:"timestamp"`
}

type SystemActivityLogs = []SystemActivityLog

type TriggerCriteria struct {
	// Polling specifies the configuration for polling-based triggers
	Polling *PollingTriggerCriteria `json:"pollingCriteria,omitempty"`

	// Event specifies the configuration for event-based triggers
	Event *EventTriggerCriteria `json:"eventCriteria,omitempty"`

	// Manual specifies the configuration for manual triggers
	Manual *ManualTriggerCriteria `json:"manualCriteria,omitempty"`

	// Webhook specifies the configuration for webhook triggers
	Webhook *WebhookTriggerCriteria `json:"webhookCriteria,omitempty"`

	// Schedule specifies the configuration for scheduled triggers
	Schedule *ScheduleTriggerCriteria `json:"scheduleCriteria,omitempty"`

	// API specifies the configuration for API triggers
	API *APITriggerCriteria `json:"apiCriteria,omitempty"`

	// Workflow specifies the configuration for workflow triggers
	Workflow *WorkflowTriggerCriteria `json:"workflowCriteria,omitempty"`

	// Message specifies the configuration for message triggers
	Message *MessageTriggerCriteria `json:"messageCriteria,omitempty"`

	// Enabled determines if the trigger is enabled
	Enabled bool `json:"enabled"`

	// MaxEvents is the maximum number of events to process at once
	MaxEvents int `json:"maxEvents,omitempty"`

	// Deduplicate determines if duplicate events should be filtered
	Filters map[string]any `json:"filters,omitempty"`
}

type TriggerSettings struct {
	// Type defines the trigger type
	Type TriggerType `json:"strategy,omitempty" validate:"required,oneof=SCHEDULED EVENT POLLING WEBHOOK MANUAL API WORKFLOW MESSAGE BUTTON"`

	// Criteria contains the configuration settings for the trigger
	Criteria *TriggerCriteria `json:"criteria,omitempty"`

	// RetryPolicy specifies the retry behavior for failed triggers
	RetryPolicy *RetryPolicy `json:"retryPolicy,omitempty"`

	// Description provides additional information about the trigger
	Description string `json:"description,omitempty"`

	// Tags provide searchable metadata for the trigger
	Tags []string `json:"tags,omitempty"`

	// Priority determines the execution priority when multiple triggers fire
	Priority int `json:"priority,omitempty"`
}

type TriggerType string

type WebhookTriggerCriteria struct {
	// Endpoint is the URL where the webhook should listen for incoming requests
	Endpoint string `json:"endpoint" validate:"required,url"`

	// HttpMethod specifies the HTTP method for the webhook
	HttpMethod string `json:"httpMethod" validate:"required,oneof=GET POST PUT DELETE"`

	// AuthEnabled determines if the webhook requires authentication
	AuthEnabled bool `json:"authEnabled"`

	// Headers specify required headers that must be included in the webhook requests
	Headers map[string]string `json:"headers,omitempty"`

	// QueryParams define required query parameters for validation
	QueryParams map[string]string `json:"queryParams,omitempty"`

	// ValidationSecret is used to validate webhook requests
	ValidationSecret *string `json:"validationSecret,omitempty"`

	// Enabled determines if the webhook trigger is active
	Enabled bool `json:"enabled" validate:"required"`

	// ResponseTemplate is a template for the webhook response
	ResponseTemplate string `json:"responseTemplate,omitempty"`

	// StatusCode is the HTTP status code to return
	StatusCode int `json:"statusCode,omitempty"`

	// PayloadPath is the path to extract the payload from the request
	PayloadPath string `json:"payloadPath,omitempty"`

	// ContentType is the expected content type of the webhook request
	ContentType string `json:"contentType,omitempty"`

	BasePath     string `json:"basePath,omitempty"`
	SecretHeader string `json:"secretHeader,omitempty"`
}

type WorkflowTriggerCriteria struct {
	// SourceWorkflowID is the ID of the source workflow
	SourceWorkflowID string `json:"sourceWorkflowId,omitempty"`

	// TriggerOnEvents determines which events trigger the workflow
	TriggerOnEvents []string `json:"triggerOnEvents,omitempty"`

	// InputMapping defines how to map source workflow outputs to this workflow inputs
	InputMapping map[string]string `json:"inputMapping,omitempty"`

	// Condition is a condition that must be met for the trigger to fire
	Condition string `json:"condition,omitempty"`

	Timeout time.Duration `json:"timeout,omitempty"`

	// Enabled determines if the workflow trigger is active
	Enabled bool `json:"enabled"`
}

type WriteLogLineOpts struct {
	// The step run id
	ProjectID string `json:"project_id" validate:"required,uuid"`
	// The step run id
	StepRunID *string `json:"step_run_id" validate:"omitnil,uuid"`

	// The flow run id
	FlowID string `json:"flow_id" validate:"uuid"`

	// (optional) The time when the log line was created.
	CreatedAt *time.Time

	// (required) The message of the log line.
	Message string `json:"message" validate:"required,min=1,max=10000"`

	// (optional) The level of the log line.
	Level *string `json:"level" validate:"omitnil,oneof=INFO ERROR WARN DEBUG"`

	// (optional) The metadata of the log line.
	Metadata map[string]any `json:"metadata"`
}