plugin

type Backend interface {
	// Describe reports what this backend is and what it understands. tdl
	// sends it in the handshake reply, and checks a target block against
	// the directives before generating anything.
	Describe() Description

	// Generate returns the files for one request. It returns an error only
	// when it cannot produce a response at all; a problem with the model
	// belongs in Response.diagnostics, where it reaches the user with a
	// position attached.
	Generate(ctx context.Context, req *Request) (*Response, error)
}

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

type Description struct {
	Name       string
	Version    string
	Directives []*DirectiveSpec
	Reuse      bool
}

type Diagnostic struct {
	Severity Severity     `protobuf:"varint,1,opt,name=severity,enum=tdl.plugin.v1.Severity" json:"severity,omitempty"`
	Message  string       `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
	Position *ir.Position `protobuf:"bytes,3,opt,name=position" json:"position,omitempty"`
	// contains filtered or unexported fields
}

type DirectiveSpec struct {
	Name    string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
	MinArgs int32  `protobuf:"varint,2,opt,name=min_args,json=minArgs" json:"min_args,omitempty"`
	// max_args is the largest number of arguments accepted, or -1 for any
	// number.
	MaxArgs int32 `protobuf:"varint,3,opt,name=max_args,json=maxArgs" json:"max_args,omitempty"`
	// arg_kinds constrains each argument by position. An empty list accepts
	// any kind, and a list shorter than the argument count constrains only
	// the arguments it covers.
	ArgKinds []ir.LiteralKind `protobuf:"varint,4,rep,packed,name=arg_kinds,json=argKinds,enum=tdl.ir.v1.LiteralKind" json:"arg_kinds,omitempty"`
	// repeatable says several entries of this directive at the same
	// specificity all reach the backend, in source order, rather than being
	// an error.
	Repeatable bool `protobuf:"varint,5,opt,name=repeatable" json:"repeatable,omitempty"`
	// contains filtered or unexported fields
}

type Features struct {

	// reuse says the plugin can serve more than one request on a
	// connection. It must treat each as independent.
	Reuse bool `protobuf:"varint,1,opt,name=reuse" json:"reuse,omitempty"`
	// contains filtered or unexported fields
}

type File struct {
	Path    string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"`
	Content []byte `protobuf:"bytes,2,opt,name=content" json:"content,omitempty"`
	// contains filtered or unexported fields
}

type Handshake struct {

	// framing_version is the wire framing this connection uses. Version 1 is
	// a varint length prefix followed by an encoded message, in both
	// directions. It exists so a later version can offer something else and
	// an older plugin can decline.
	FramingVersion int32 `protobuf:"varint,1,opt,name=framing_version,json=framingVersion" json:"framing_version,omitempty"`
	// ir_version is the protobuf package the model is encoded with, such as
	// "tdl.ir.v1". Within a version, field numbers are never reused and new
	// fields are additive.
	IrVersion string `protobuf:"bytes,2,opt,name=ir_version,json=irVersion" json:"ir_version,omitempty"`
	// watch says this connection may serve more than one request, which a
	// plugin declaring reuse should expect.
	Watch bool `protobuf:"varint,3,opt,name=watch" json:"watch,omitempty"`
	// contains filtered or unexported fields
}

type HandshakeReply struct {
	Accepted bool `protobuf:"varint,1,opt,name=accepted" json:"accepted,omitempty"`
	// refusal says what the plugin needed, when accepted is false. A
	// refusal naming both versions is the point of the handshake.
	Refusal string `protobuf:"bytes,2,opt,name=refusal" json:"refusal,omitempty"`
	Name    string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
	Version string `protobuf:"bytes,4,opt,name=version" json:"version,omitempty"`
	// directives are what this backend understands. tdl checks the target
	// block against them before generating; see DirectiveSpec.
	Directives []*DirectiveSpec `protobuf:"bytes,5,rep,name=directives" json:"directives,omitempty"`
	Features   *Features        `protobuf:"bytes,6,opt,name=features" json:"features,omitempty"`
	// contains filtered or unexported fields
}

type Request struct {

	// target names the block being served. The model carries directives for
	// every target block in it, each tagged with the block it came from, so
	// a backend keeps the ones matching this name.
	Target string `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
	// model is one package, with the prelude's declarations merged into it.
	// See docs/design/plugins.md for what that means for a backend.
	Model *ir.Model `protobuf:"bytes,2,opt,name=model" json:"model,omitempty"`
	// out is the directory the response's paths are relative to.
	Out string `protobuf:"bytes,3,opt,name=out" json:"out,omitempty"`
	// dry_run says tdl will diff the response against disk rather than
	// write it. A backend that would do expensive work it knows cannot
	// affect the answer may skip it; one that ignores the flag is correct,
	// only slower.
	DryRun bool `protobuf:"varint,4,opt,name=dry_run,json=dryRun" json:"dry_run,omitempty"`
	// contains filtered or unexported fields
}

type Response struct {
	Files []*File `protobuf:"bytes,1,rep,name=files" json:"files,omitempty"`
	// post names commands to run over the written files, by name only. The
	// project decides what a name maps to; a name it has not declared is
	// skipped with a warning.
	Post        []string      `protobuf:"bytes,2,rep,name=post" json:"post,omitempty"`
	Diagnostics []*Diagnostic `protobuf:"bytes,3,rep,name=diagnostics" json:"diagnostics,omitempty"`
	// contains filtered or unexported fields
}

type Severity int32