arazzo

type ArazzoDocumentFactory func(sourceURL string, bytes []byte) (*high.Arazzo, error)

type ArazzoSourceAdapter interface {
	SourceDocumentAdapter
	HasWorkflow(string) bool
}

type AsyncAPISourceAdapter interface {
	SourceDocumentAdapter
	HasChannel(string) bool
	HasOperation(string) bool
}

type CandidateDocument struct {
	Type             string
	ResolvedIdentity string
	RetrievalURI     string
	SourceBytes      []byte
	RootNode         *yaml.Node
	OpenAPIDocument  *v3high.Document
	ArazzoDocument   *high.Arazzo
	Adapter          SourceDocumentAdapter
}

type CandidateDocumentProvider interface {
	Documents(context.Context) ([]CandidateDocument, error)
}

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

type EngineConfig struct {
	RetainResponseBodies bool // If false, nil out response bodies after extracting outputs

	// SleepFunc, when non-nil, replaces the engine's default wait between
	// retry attempts (a failure action's retryAfter). The engine calls it
	// with the workflow context and the retryAfter duration; returning an
	// error aborts the workflow, exactly as a cancelled context does with
	// the default sleeper.
	//
	// Injecting it lets a host substitute its own timer: a durable workflow
	// runtime (Temporal, DBOS, Restate) passes its replay-safe durable
	// sleep — a real time.Timer inside a replayed workflow body would block
	// the scheduler or break determinism — and tests pass a recording fake
	// to avoid real waits. Nil uses the default context-aware timer.
	SleepFunc func(ctx context.Context, d time.Duration) error
}

type ExecutionRequest struct {
	Source        *ResolvedSource
	OperationID   string
	OperationPath string
	Method        string
	Parameters    map[string]any
	RequestBody   any
	ContentType   string
}

type ExecutionResponse struct {
	StatusCode int
	Headers    map[string][]string
	Body       any
	URL        string // Actual request URL (populated by Executor)
	Method     string // HTTP method used (populated by Executor)
}

type Executor interface {
	Execute(ctx context.Context, req *ExecutionRequest) (*ExecutionResponse, error)
}

type HTTPSourceHandler func(context.Context, string) ([]byte, error)

type InMemoryResolverConfig struct {
	OpenAPIFactory OpenAPIDocumentFactory
	ArazzoFactory  ArazzoDocumentFactory
	Fallback       SourceDocumentResolver
	MaxSources     int // Maximum candidate documents to accept (default: 50).
}

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

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

type OpenAPIDocumentFactory func(sourceURL string, bytes []byte) (*v3high.Document, error)

type OpenAPISourceAdapter interface {
	SourceDocumentAdapter
	HasOperationID(string) bool
	HasOperationPath(string) bool
}

type ResolveConfig struct {
	OpenAPIFactory OpenAPIDocumentFactory // Creates *v3high.Document from bytes
	ArazzoFactory  ArazzoDocumentFactory  // Creates *high.Arazzo from bytes
	BaseURL        string
	// HTTPHandlerWithContext is preferred for custom retrieval because it can
	// stop work when ResolveSourcesWithContext is cancelled or times out.
	HTTPHandlerWithContext HTTPSourceHandler
	// HTTPHandler is retained for compatibility. It is checked for cancellation
	// before invocation, but its legacy signature cannot stop in-flight work.
	HTTPHandler func(url string) ([]byte, error)
	HTTPClient  *http.Client
	FSRoots     []string

	Timeout        time.Duration // Per-source fetch timeout (default: 30s)
	MaxBodySize    int64         // Max response body in bytes (default: 10MB)
	AllowedSchemes []string      // URL scheme allowlist (default: ["https", "http", "file"])
	AllowedHosts   []string      // Host allowlist (nil = allow all)
	MaxSources     int           // Max source descriptions to resolve (default: 50)
}

type ResolvedSource struct {
	Name            string           // SourceDescription name
	URL             string           // Resolved URL
	Identity        string           // Portable resolved identity, usually resolved $self
	RetrievalURI    string           // Location from which the document was retrieved
	Type            string           // "openapi" or "arazzo"
	SourceBytes     []byte           // Original source bytes when supplied or retrieved
	RootNode        *yaml.Node       // Original root node when supplied
	OpenAPIDocument *v3high.Document // Non-nil when Type == "openapi"
	ArazzoDocument  *high.Arazzo     // Non-nil when Type == "arazzo"
	Adapter         SourceDocumentAdapter
}

type RunResult struct {
	Workflows []*WorkflowResult
	Success   bool
	Duration  time.Duration
}

type SourceDocumentAdapter interface {
	SourceType() string
}

type SourceDocumentResolver interface {
	Resolve(context.Context, SourceRequest) (*ResolvedSource, error)
}

type SourceRequest struct {
	Name    string
	URL     string
	Type    string
	BaseURI string
}

type StepFailureError struct {
	StepId         string
	CriterionIndex int // -1 if not criterion-related
	Message        string
	Cause          error
}

type StepResult struct {
	StepId     string
	Success    bool
	StatusCode int
	Outputs    map[string]any
	Error      error
	Duration   time.Duration
	Retries    int
}

type UnsupportedExecutionFeatureError struct {
	WorkflowId string
	StepId     string
	Field      string
}

type UnsupportedSelectorOutputError struct {
	WorkflowId string
	StepId     string
	OutputName string
}

type ValidationError struct {
	Path   string // e.g. "workflows[0].steps[2].parameters[1]"
	Line   int
	Column int
	Cause  error
}

type ValidationResult struct {
	Errors   []*ValidationError
	Warnings []*Warning
}

type Warning struct {
	Path    string
	Line    int
	Column  int
	Message string
}

type WorkflowResult struct {
	WorkflowId string
	Success    bool
	Inputs     map[string]any
	Outputs    map[string]any
	Steps      []*StepResult
	Error      error
	Duration   time.Duration
}