model

type Async struct {
	Protocol string // ws, sse, mqtt, kafka, amqp or nats
	Server   string // templated; e.g. mqtt://host:1883
	Channel  string // topic, subject, queue, or routing key
	Send     *AsyncSend
	Receive  *AsyncReceive
	// Binding is the protocol's own options (qos, key, exchange, …), in
	// file order; the allowed names depend on the protocol.
	Binding []KeyValue
}

type AsyncReceive struct {
	Count   int
	Timeout time.Duration
	// Match, when set, is an expression a message must satisfy to count.
	Match string
}

type AsyncSend struct {
	Body    Body
	Headers []KeyValue
}

type Blueprint struct {
	Meta
	Path string
	// Phase says which hooks of a request the blueprint's nodes can be: "pre"
	// or "post"; empty means post. It does not matter to a blueprint used to
	// make a flow.
	Phase  string
	Params []Param
	Body   Flow
	File   string
}

type Body struct {
	JSON      string
	Text      string
	File      string
	Form      []KeyValue
	Multipart []Field
}

type Branch struct {
	ID    string
	Nodes []Node
}

type Case struct {
	When  string
	Nodes []Node
}

type Collection struct {
	Root         string
	Manifest     Manifest
	Folders      []Folder
	Environments []Environment
	Requests     []Request
	Flows        []Flow
	Blueprints   []Blueprint
}

type Dependency struct {
	ID   ID
	Name string
	Repo string // optional clone URL shown when the dependency is not mounted
}

type EnvVar struct {
	Name   string
	Value  string
	Secret bool
}

type Environment struct {
	Meta
	Vars []EnvVar
	File string
	// Colour marks the environment wherever it is chosen, so that one is not mistaken for another.
	// It is one of EnvColours(), or empty for the default; an unknown name is shown as the default.
	Colour string
	// Scope is the vault scope of this environment's secrets. Empty means
	// the owning collection; global environments carry the workspace scope.
	Scope ID
}

type Execution struct {
	MaxConcurrency int
	RateLimit      string
	HostRateLimits []KeyValue
	OnBranchError  string
}

type Extraction struct {
	Name   string
	From   string
	Path   string
	Header string
	Cookie string
	Regex  string
}

type Field struct {
	Key   string
	Value any
}

type Flow struct {
	Meta
	Path          string
	PreferVersion string
	Inputs        []Input
	Outputs       []KeyValue // name → template rendered when the flow ends (subflows)
	Execution     Execution
	Run           *RunTill
	Nodes         []Node
	File          string
}

type Folder struct {
	Dir      string
	Settings Settings
	Hooks    Hooks
	// Order lists the names of the folder's entries (a request or flow without its
	// file suffix, or a sub-folder's name) in the order they are shown. Entries it
	// does not name follow, by name; a name that matches nothing is ignored.
	Order []string
	File  string
}

type GRPC struct {
	// Server is grpc://host:port (plaintext), grpcs://host:port (TLS) or a bare
	// host:port; templated, e.g. {{env.api}}.
	Server string
	// Method is package.Service/Method.
	Method string
	// Body is the request message, as JSON (or text holding JSON).
	Body Body
	// Proto lists .proto files, relative to the collection. Empty: the schema
	// is asked of the server by reflection.
	Proto []string
	// Import lists the roots .proto imports are resolved against, relative to
	// the collection.
	Import []string
	// Receive says which messages of a server stream to keep; unused for a
	// unary call. Count 0 means 1 and Timeout 0 means 30s when it runs.
	Receive *AsyncReceive
}

type HookControl struct {
	Mode string
	Skip []string
}

type HookStep struct {
	Flow   *Ref
	Inline []Node
}

type Hooks struct {
	Pre  []HookStep
	Post []HookStep
}

type ID string

type Input struct {
	Name    string
	Default string
}

type KeyValue struct {
	Key   string
	Value string
	// Description says what the entry is for; only requests keep it (query,
	// headers, variables).
	Description string
}

type Layout struct {
	Flow      ID
	Nodes     map[string]Point // manual positions by node id
	Collapsed []string         // collapsed action strips, by first node id
	File      string
}

type Manifest struct {
	Format int
	Meta
	DependsOn []Dependency
	Settings  Settings
	Hooks     Hooks
	File      string
}

type Meta struct {
	ID          ID
	Name        string
	Description string
}

type Mount struct {
	ID   ID
	Path string // as the user gave it; may start with "~"
}

type Node struct {
	ID          string
	Type        NodeType
	Name        string
	Description string
	Needs       []string
	When        string
	Concurrent  bool
	OnError     string
	Timeout     time.Duration
	// Attach names a request or subflow node of the same list that this node is shown
	// with: the canvas draws them as one block. It is a view only; the run order is
	// the list order, as always.
	Attach string
	// AttachAt says where, around that request, the canvas draws the node: "above" or
	// "below" it in a stack, or "" beside it (before it in the list is drawn left of it,
	// after it right of it). Like Attach it is a view only.
	AttachAt string

	Request  *RequestCall
	Subflow  *SubflowCall
	Body     []Node
	Branches []Branch
	Then     []Node
	Else     []Node
	Cases    []Case
	Params   []Field
}

type NodeType string

type Param struct {
	Name        string
	Type        ParamType
	Description string
	Default     string
}

type ParamType string

type Point struct{ X, Y int64 }

type Ref struct {
	Collection string
	ID         ID
	Path       string
	// Param, set only inside a blueprint, names the blueprint parameter
	// that fills this reference when the blueprint is used; ID and Path are
	// then empty.
	Param string
}

type Request struct {
	Meta
	Path      string
	Operation string // the OpenAPI operationId of its first version; Arazzo steps refer to it
	Default   string
	Versions  []RequestVersion
	Hooks     Hooks
	File      string

	// Edit is the one dirty edit: an autosaved working copy of a version.
	// Runs, serve and the CLI ignore it; only the GUI sends it. EditBase is
	// the label of the version it started from.
	Edit     *RequestVersion
	EditBase string
}

type RequestCall struct {
	Request Ref
	Version string
	Hooks   HookControl
	With    []KeyValue
	Headers []KeyValue
}

type RequestVersion struct {
	Label string
	// Name is a short title for the version ("Before the tax change"); the label
	// ("1.1") stays what it is called everywhere else. Docs is its description.
	Name     string
	Method   string
	URL      string
	Query    []KeyValue
	Headers  []KeyValue
	Body     Body
	Extract  []Extraction
	Assert   []string
	Settings Settings
	Hooks    Hooks
	// Variables are the version's default values for {{var.name}}; the
	// environment's variable of the same name wins.
	Variables []KeyValue
	// Docs is the version's documentation, written as Markdown.
	Docs string
	// Async, when set, makes this an async (message) request instead of an
	// HTTP one: Method, Query and Body are then unused.
	Async *Async
	// GRPC, when set, makes this a gRPC call instead of an HTTP request. The
	// version's Headers are the call's metadata; Method, URL, Query and Body
	// are unused.
	GRPC *GRPC
}

type RunTill struct {
	Until         string
	MaxIterations int
	MaxDuration   time.Duration
	Interval      time.Duration
}

type Schedule struct {
	Name       string // unique within the workspace; names the schedule in logs and commands
	Flow       string // a flow path or id
	Collection string // optional: a collection name or id when Flow is ambiguous
	Cron       string // five fields, or @hourly, @daily, …
	Env        string // environment name; "" uses defaults.environment
	Inputs     []KeyValue
	TZ         string // IANA zone name; "" is the machine's zone
	Disabled   bool
}

type Settings map[string]any

type SubflowCall struct {
	Flow Ref
	With []KeyValue
}

type Workspace struct {
	Meta
	Collections []Mount
	Schedules   []Schedule
	Settings    Settings
	File        string
}