plugin

type Backend interface {
	// Describe reports what this backend is and what directives it
	// understands. tdl checks a target block against them before
	// generating.
	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.
	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

	// Reverse says the backend is an [Importer].
	Reverse 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"`
	// code names the kind of problem, such as "lossy.collection". A warning
	// a user can silence carries one; see docs/design/reverse.md.
	Code string `protobuf:"bytes,4,opt,name=code" json:"code,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. Otherwise they are
	// 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"`
	// reverse says the plugin answers MODE_IMPORT, reading its target
	// language back into a model.
	Reverse bool `protobuf:"varint,2,opt,name=reverse" json:"reverse,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.
	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.
	Watch bool `protobuf:"varint,3,opt,name=watch" json:"watch,omitempty"`
	// mode says which requests follow: Request, or ImportRequest under
	// MODE_IMPORT.
	Mode Mode `protobuf:"varint,4,opt,name=mode,enum=tdl.plugin.v1.Mode" json:"mode,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. It should
	// name both versions.
	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.
	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 ImportRequest struct {

	// target names the backend's language, as in Request.target. Directives
	// the backend writes into the model's target blocks name it.
	Target string `protobuf:"bytes,1,opt,name=target" json:"target,omitempty"`
	// files are the source files to read, with the paths the user gave.
	Files []*File `protobuf:"bytes,2,rep,name=files" json:"files,omitempty"`
	// allow_lossy are the loss codes the user allowed. tdl drops warnings
	// carrying them, so a backend may skip the work of finding them; ignoring
	// the list is correct.
	AllowLossy []string `protobuf:"bytes,3,rep,name=allow_lossy,json=allowLossy" json:"allow_lossy,omitempty"`
	// contains filtered or unexported fields
}

type ImportResponse struct {

	// model holds the declarations read, in the shape lowering produces.
	// tdl prints only the declarations not positioned in the prelude.
	Model       *ir.Model     `protobuf:"bytes,1,opt,name=model" json:"model,omitempty"`
	Diagnostics []*Diagnostic `protobuf:"bytes,2,rep,name=diagnostics" json:"diagnostics,omitempty"`
	// contains filtered or unexported fields
}

type Importer interface {
	Backend

	// Import returns the model the request's files describe. It returns an
	// error only when it cannot produce a response at all; a problem with
	// the files belongs in ImportResponse.diagnostics.
	Import(ctx context.Context, req *ImportRequest) (*ImportResponse, error)
}

type Mode int32

type Request struct {

	// target names the block being served. A backend keeps the directives
	// tagged with 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.
	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 may skip work that cannot affect the files; ignoring
	// the flag is correct.
	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