func (d *Decoder) Decode(dst interface{}, src map[string][]string) error {
	v := reflect.ValueOf(dst)
	if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
		return errors.New("schema: interface must be a pointer to struct")
	}
	v = v.Elem()
	t := v.Type()
	errors := MultiError{}
	for path, values := range src {
		if parts, err := d.cache.parsePath(path, t); err == nil {
			if err = d.decode(v, path, parts, values); err != nil {
				errors[path] = err
			}
		} else if !d.ignoreUnknownKeys {
			errors[path] = fmt.Errorf("schema: invalid path %q", path)
		}
	}
	if len(errors) > 0 {
		return errors
	}
	return d.checkRequired(t, src, "")
}
Decode decodes a map[string][]string to a struct.

The first parameter must be a pointer to a struct.

The second parameter is a map, typically url.Values from an HTTP request.
Keys are "paths" in dotted notation to the struct fields and nested structs.

See the package documentation for a full explanation of the mechanics.
package schema
import (
	"encoding"
	"errors"
	"fmt"
	"reflect"
	"strings"
)
func NewDecoder() *Decoder {
	return &Decoder{cache: newCache()}
}
type Decoder struct {
	cache             *cache
	zeroEmpty         bool
	ignoreUnknownKeys bool
}
func (d *Decoder) SetAliasTag(tag string) {
	d.cache.tag = tag
}
func (d *Decoder) ZeroEmpty(z bool) {
	d.zeroEmpty = z
}
func (d *Decoder) IgnoreUnknownKeys(i bool) {
	d.ignoreUnknownKeys = i
}
func (d *Decoder) RegisterConverter(value interface{}, converterFunc Converter) {
	d.cache.regconv[reflect.TypeOf(value)] = converterFunc
}