func Interface(name NameDeclr, comments io.WriterTo, annotations io.WriterTo, fields ...io.WriterTo) StructDeclr {
	if annotations == nil {
		annotations = bytes.NewBuffer(nil)
	}
	if comments == nil {
		comments = bytes.NewBuffer(nil)
	}
	return StructDeclr{
		Type:        Type("interface"),
		Name:        name,
		Comments:    comments,
		Annotations: annotations,
		Fields:      fields,
	}
}
Interface returns a new instance of a StructDeclr to generate a go struct.
package gen
import (
	"bytes"
	"fmt"
	"io"
	"text/template"
)
func RuneASCII(rn rune) RuneASCIIDeclr {
	return RuneASCIIDeclr{
		Value: rn,
	}
}
func RuneGraphics(rn rune) RuneGraphicsDeclr {
	return RuneGraphicsDeclr{
		Value: rn,
	}
}
func Rune(rn rune) RuneDeclr {
	return RuneDeclr{
		Value: rn,
	}
}
func StringASCII(rn string) StringASCIIDeclr {
	return StringASCIIDeclr{
		Value: rn,
	}
}
func Bool(rn bool) BoolDeclr {
	return BoolDeclr{
		Value: rn,
	}
}
func FloatBase(rn float64, bit, prec int) FloatBaseDeclr {
	return FloatBaseDeclr{
		Value:     rn,
		Bitsize:   bit,
		Precision: prec,
	}
}
func Float32(rn float32) Float32Declr {
	return Float32Declr{
		Value: rn,
	}
}
func Float64(rn float64) Float64Declr {
	return Float64Declr{
		Value: rn,
	}
}
func IntBase(rn int64, base int) IntBaseDeclr {
	return IntBaseDeclr{
		Value: rn,
		Base:  base,
	}
}
func Int32(rn int32) Int32Declr {
	return Int32Declr{
		Value: rn,
	}
}
func Int64(rn int64) Int64Declr {
	return Int64Declr{
		Value: rn,
	}
}
func Int(rn int) IntDeclr {
	return IntDeclr{
		Value: rn,
	}
}
func UIntBase(rn uint64, base int) UIntBaseDeclr {
	return UIntBaseDeclr{
		Value: rn,
		Base:  base,
	}
}
func UInt32(rn uint32) UInt32Declr {
	return UInt32Declr{
		Value: rn,
	}
}
func UInt64(rn uint64) UInt64Declr {
	return UInt64Declr{
		Value: rn,
	}
}
func Value(rn interface{}, converter func(interface{}) string) ValueDeclr {
	return ValueDeclr{
		Value:          rn,
		ValueConverter: converter,
	}
}
func Fmt(txt string, fm ...interface{}) io.WriterTo {
	return TextBlockDeclr{
		Text: fmt.Sprintf(txt, fm...),
	}
}
func JSON(documents ...io.WriterTo) JSONDeclr {
	return JSONDeclr{
		Documents: documents,
	}
}
func JSONDocument(contents map[string]io.WriterTo) JSONBlock {
	return JSONBlock{
		Items: contents,
	}
}
func Text(txt string) TextBlockDeclr {
	return TextBlockDeclr{
		Text: txt,
	}
}
func String(rn string) StringDeclr {
	return StringDeclr{
		Value: rn,
	}
}
func Imports(ims ...ImportItemDeclr) ImportDeclr {
	return ImportDeclr{
		Packages: ims,
	}
}
func Import(path string, namespace string) ImportItemDeclr {
	return ImportItemDeclr{
		Namespace: namespace,
		Path:      path,
	}
}
func AssignMap(name string, maptype string, mapvalue string) VariableShortAssignmentDeclr {
	return Var(Name(name), MapValueVar(maptype, mapvalue))
}
func MapVar(name string, maptype string, mapvalue string) VariableTypeDeclr {
	return VarType(Name(name), MapType(maptype, mapvalue))
}
func MapValueVar(mapType string, mapValue string) TypeDeclr {
	return Type(fmt.Sprintf("map[%s]%s{}", mapType, mapValue))
}
func CustomMapValueVar(mapdefType, mapType string, mapValue string) TypeDeclr {
	return Type(fmt.Sprintf("%s[%s]%s{}", mapdefType, mapType, mapValue))
}
func MapType(maptype string, mapvalue string) TypeDeclr {
	return Type(fmt.Sprintf("map[%s]%s", maptype, mapvalue))
}
func CustomMapType(mapdefType, mapType string, mapValue string) TypeDeclr {
	return Type(fmt.Sprintf("%s[%s]%s", mapdefType, mapType, mapValue))
}
func Map(mapkeyType string, mapkeyValue string, values map[string]io.WriterTo) MapDeclr {
	return TMap("map", mapkeyType, mapkeyValue, values)
}
func TMap(mapType string, mapkeyType string, mapkeyValue string, values map[string]io.WriterTo) MapDeclr {
	return MapDeclr{
		Values:  values,
		MapType: Name(mapType),
		Type:    Name(mapkeyType),
		Value:   Name(mapkeyValue),
	}
}
func Type(name string) TypeDeclr {
	return TypeDeclr{
		TypeName: name,
	}
}
func FmtName(name string, vals ...interface{}) NameDeclr {
	return NameDeclr{
		Name: fmt.Sprintf(name, vals...),
	}
}
func Name(name string) NameDeclr {
	return NameDeclr{
		Name: name,
	}
}
func Package(name io.WriterTo, dirs ...io.WriterTo) PackageDeclr {
	return PackageDeclr{
		Name: name,
		Body: dirs,
	}
}
func CustomReturns(returns ...io.WriterTo) CustomReturnDeclr {
	return CustomReturnDeclr{
		Returns: returns,
	}
}
func Returns(returns ...TypeDeclr) ReturnDeclr {
	return ReturnDeclr{
		Returns: returns,
	}
}
func Constructor(args ...VariableTypeDeclr) ConstructorDeclr {
	return ConstructorDeclr{
		Arguments: args,
	}
}