arazzo

type AsyncSchemaLookup interface {
	RequestSchema(r model.Request, version string) (map[string]any, bool)
	MessageSchema(r model.Request, version string) (map[string]any, bool)
}

type CustomStep struct {
	Node  string // the node's id
	Type  string // the node's type
	Index int    // its place among the flow's top-level nodes ($.nodes[Index])
}

type ExportOptions struct {
	Resolve Resolver
	// Source names the OpenAPI source description the steps call;
	// SourceURL is its url (default "./<Source>.openapi.yaml").
	Source    string
	SourceURL string
	// AsyncSourceURL is the url of the AsyncAPI source description a flow
	// with async steps adds (default "./requests.asyncapi.yaml").
	AsyncSourceURL string
	Title          string // info.title (default: the first flow's name)
}

type FlowBody interface {
	EncodeFlow(model.Flow) ([]byte, error)
	DecodeFlow(file, path string, data []byte) (model.Flow, diag.List)
}

type FlowOptions struct {
	Body    FlowBody
	Resolve Resolver
	// Sources are the document's source descriptions; the first is the
	// collection's generated description and must be named "flowi".
	Sources []SourceDescription
	NewID   func() model.ID // an id for a flow read from a foreign document
}

type Limit struct {
	Node string // the node's id
	What string
}

type Operation struct {
	ID     string
	Params map[string]Param
	// Async operations (AsyncAPI) set the rest: Source names the source
	// description the operation is in ("" → the OpenAPI one), Action is send
	// or receive, Timeout is how long a receive waits, and Reply and Match
	// say the request also waits for a reply, or filters the messages it
	// counts: neither has a place in an Arazzo step.
	Source  string
	Action  string
	Timeout time.Duration
	Reply   bool
	Match   bool
	// Custom names a kind of request that has no standard description ("gRPC call", "dataset query"): its step is
	// a custom one that keeps the call in x-flowi-flow. Empty for a request that has one.
	Custom string
}

type Options struct {
	NewID   func() model.ID // ids for new flows
	Resolve Resolver
}

type Param struct {
	Name, In string
}

type Resolver interface {
	RequestFor(operationID string) (model.Ref, string, bool)
	OperationOf(call model.RequestCall) (Operation, bool)
}

type Result struct {
	Flows []model.Flow
}

type SchemaLookup interface {
	RequestSchema(r model.Request, version string) (map[string]any, bool)
	ResponseSchemas(r model.Request, version string) map[int]map[string]any
}

type SourceDescription struct{ Name, URL, Type string }