func (c *client) GetDetails() (*Details, error) {
	op := client.Operation{
		HTTPMethod: http.MethodGet,
		HTTPPath:   endpoint + "/v1/getdetails",
	}

	var response *Details
	req, err := r.cl.NewRequest(op, &response, nil)
	if err != nil {
		return response, nil
	}
	if err := req.Send(); err != nil {
		return response, nil
	}

	return response, nil
}

func (c *client) GetRandomStuff() (*RandomStuff, error) {
	op := client.Operation{
		HTTPMethod: http.MethodGet,
		HTTPPath:   endpoint + "/v1/getrandomstuff",
	}

	var response *RandomStuff
	req, err := r.cl.NewRequest(op, &response, nil)
	if err != nil {
		return response, nil
	}
	if err := req.Send(); err != nil {
		return response, nil
	}

	return response, nil
}

type Generator interface {
	Generate(Reader, Writer) error
}

// Reader is a general wrapper on io.Reader to read an input to obtain
// the apis.
type Reader interface {
	ReadAPI(io.Reader) ([]API, error)
}

// Writer is a general wrapper on io.Writer to write the processed file.
type Writer interface {
	WriteAPI(io.Writer, []API) error
}

{
    "methods": [
        {
            "name": "GetDetails",
            "endpoint": "v1/getdetails",
            "verb": "Get",
            "inputParams": [],
            "outputParams": [
                {"Details": {}}
            ]
        },
        {
            "name": "GetRandomStuff",
            "endpoint": "v1/getrandomstuff",
            "verb": "Get",
            "inputParams": [],
            "outputParams": [
                {"RandomStuff": {}}
            ]
        }
    ]
}

type Client interface{
    // Get v1/getdetails
    GetDetails() (*Details, error) 

    // Get v1/getrandomstuff
    GetRandomStuff() (*RandomStuff, error) 
}

type Details struct{}

type RandomStuff struct{}

    fs := token.NewFileSet()
	p, err := parser.ParseFile(fs, "", r, parser.ParseComments)
	if err != nil {
		return nil, err
    }

// API is a set of indicatives that we will loop through
// to generate code.
type API struct {
	InterfaceName string
	Methods       []Method
}

// Method represents a set of metadata levels details that belong
// to an api method.
type Method struct {
	Endpoint     string
	MethodName   string
	Path         string
	Verb         string
	Body         string
	InputParams  []Parameter
	OutputParams []Parameter
}

...
	// loop through all the top level declarations of the AST.
	for _, decl := range p.Decls {
		// We don't care about functional declarations, so lets pick
		// only the generic ones.
		decl, ok := decl.(*ast.GenDecl)
		// We don't really need to process token.TYPE.
		if !ok || decl.Tok != token.TYPE {
			continue
		}

		var api API
		for _, spec := range decl.Specs {
			//We only want to read through type declarations.
			typeSpec, ok := spec.(*ast.TypeSpec)
			if !ok {
				continue
			}

			api.InterfaceName = typeSpec.Name.String()

			// Again, we are only interested in Interface definitions.
			interfaceType, ok := typeSpec.Type.(*ast.InterfaceType)
			if !ok {
				continue
			}
...

    func getMethods(fields []*ast.Field) []Method {
    	var methods = make([]Method, 0)
    	for _, method := range fields {
    		if len(method.Names) == 0 {
    			continue
    		}
    
    		var ignore bool
    		var matches [][]string
    		for _, d := range method.Doc.List {
    			comment := extractComment(d.Text)
    			if comment == "Ignore" {
    				ignore = true
    			} else {
    				matches = verbEndpointRegex.FindAllStringSubmatch(comment, -1)
    			}
    		}
    		if ignore {
    			continue
    		}
    
    		fn, ok := method.Type.(*ast.FuncType)
    		if !ok {
    			continue
    		}
    
    		var methodData Method
    		methodData.Verb = matches[0][0]
    		methodData.Path = matches[1][0]
    		methodData.MethodName = method.Names[0].String()
    		methodData.InputParams = getFields(fn.Params.List)
    		methodData.OutputParams = getFields(fn.Results.List)
    
    		methods = append(methods, methodData)
    	}
    	return methods
    }
    
    func extractComment(comment string) string {
    	slashRemoved := strings.Trim(comment, "//")
    	return strings.Trim(slashRemoved, " ")
    }
    
    func getFields(fields []*ast.Field) []Parameter {
    	params := make([]Parameter, 0)
    	for _, field := range fields {
    		var name string
    		if len(field.Names) > 0 {
    			name = field.Names[0].Name
    		}
    		switch t := field.Type.(type) {
    		case *ast.SelectorExpr:
    			p := Parameter{
    				Name: name,
    				Type: selectorToString(t),
    			}
    			params = append(params, p)
    		case *ast.StarExpr:
    			p := Parameter{
    				Name: name,
    				Type: starToString(t),
    			}
    			params = append(params, p)
    		case *ast.Ident:
    			p := Parameter{
    				Name: name,
    				Type: t.Name,
    			}
    			params = append(params, p)
    		}
    
    	}
    	return params
    }
    
    func selectorToString(t *ast.SelectorExpr) string {
    	var param bytes.Buffer
    	if ident, ok := t.X.(*ast.Ident); ok {
    		param.WriteString(ident.Name)
    	}
    	param.WriteString(".")
    	param.WriteString(t.Sel.Name)
    	return param.String()
    }
    
    func starToString(t *ast.StarExpr) string {
    	var param bytes.Buffer
    	param.WriteString("*")
    	if ident, ok := t.X.(*ast.Ident); ok {
    		param.WriteString(ident.Name)
    	}
    	return param.String()
    }

const fnTmpl = `
		{{$i := separator ", "}}
		{{$o := separator ", "}}
		{{$length := len .OutputParams}}
		func (c *client) {{.MethodName}} ({{range .InputParams}}{{call $i}}{{.Name}} {{.Type}}{{end}}) ( 
		{{range .OutputParams}} {{call $o}} {{.Name}} {{.Type}} {{end}}){
			op := client.Operation{
				HTTPMethod: http.Method{{.Verb}},
				HTTPPath:   endpoint + "/{{.Path}}",
			}

			{{.Body}}

			var response {{(index .OutputParams 0).Type}}
			req, err := c.cl.NewRequest(op, &response, nil)
			if err != nil {
				{{if eq $length 1}} return nil {{ else }} return response, nil {{ end }} 
			}
			if err := req.Send(); err != nil {
				{{if eq $length 1}} return nil {{ else }} return response, nil {{ end }} 
			}

			{{if eq $length 1}} return nil {{ else }} return response, nil {{ end }} 
		}
`

func separator(s string) func() string {
	i := -1
	return func() string {
		i++
		if i == 0 {
			return ""
		}
		return s
	}
}

for _, api := range apis {
	for _, method := range api.Methods {
		t := template.Must(template.New("func").
			Funcs(template.FuncMap{"separator": separator}).
			Parse(fnTmpl))
		t.Execute(&buf, method)
	}
}

//go:generate go run internal/cmd/genmethods/generator.go