func (r *Result) Uint64() (uint64, error) {
	switch v := r.value.(type) {
	case float64:
		return uint64(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
Uint64 assert the result to uint64
package gojsonq
import (
	"fmt"
	"reflect"
	"strings"
	"time"
)
const errMessage = "gojsonq: wrong method call for %v"
var (
	ErrExpectsPointer = fmt.Errorf("gojsonq: failed to unmarshal, expects pointer")
	ErrImmutable      = fmt.Errorf("gojsonq: failed to unmarshal, target is not mutable")
	ErrTypeMismatch   = fmt.Errorf("gojsonq: failed to unmarshal, target type misatched")
)
func NewResult(v interface{}) *Result {
	return &Result{value: v}
}
type Result struct {
	value interface{}
}
func (r *Result) Nil() bool {
	return r.value == nil
}
func (r *Result) As(v interface{}) error {
	if r.value != nil {
		rv := reflect.ValueOf(v)
		if rv.Kind() != reflect.Ptr || rv.IsNil() {
			return ErrExpectsPointer
		}
		elm := rv.Elem()
		if !elm.CanSet() {
			return ErrImmutable
		}
		method := rv.Type().String()
		methodMap := map[string]string{
			"*string": "String", "*bool": "Bool", "*time.Duration": "Duration",
			"*int": "Int", "*int8": "Int8", "*int16": "Int16", "*int32": "Int32",
			"*uint": "Uint", "*uint8": "Uint8", "*uint16": "Uint16", "*uint32": "Uint32",
			"*float32": "Float32", "*float64": "Float64",
			"*[]string": "StringSlice", "*[]bool": "BoolSlice", "*[]time.Duration": "DurationSlice",
			"*[]int": "IntSlice", "*[]int8": "Int8Slice", "*[]int16": "Int16Slice", "*[]int32": "Int32Slice",
			"*[]uint": "UintSlice", "*[]uint8": "Uint8Slice", "*[]uint16": "Uint16Slice", "*[]uint32": "Uint32Slice",
			"*[]float32": "Float32Slice", "*[]float64": "Float64Slice",
		}
		if methodMap[method] == "" {
			return fmt.Errorf("gojsonq: type [%T] is not available", v)
		}
		vv := reflect.ValueOf(r).MethodByName(methodMap[method]).Call(nil)
		if vv != nil {
			if vv[1].Interface() != nil {
				return ErrTypeMismatch
			}
			rv.Elem().Set(vv[0])
		}
	}
	return nil
}
func (r *Result) Bool() (bool, error) {
	switch v := r.value.(type) {
	case bool:
		return v, nil
	default:
		return false, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Time(layout string) (time.Time, error) {
	switch v := r.value.(type) {
	case string:
		return time.Parse(layout, v)
	default:
		return time.Time{}, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Duration() (time.Duration, error) {
	switch v := r.value.(type) {
	case float64:
		return time.Duration(v), nil
	case string:
		if strings.ContainsAny(v, "nsuµmh") {
			return time.ParseDuration(v)
		}
		return time.ParseDuration(v + "ns")
	default:
		return time.Duration(0), fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) String() (string, error) {
	switch v := r.value.(type) {
	case string:
		return v, nil
	default:
		return "", fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Int() (int, error) {
	switch v := r.value.(type) {
	case float64:
		return int(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Int8() (int8, error) {
	switch v := r.value.(type) {
	case float64:
		return int8(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Int16() (int16, error) {
	switch v := r.value.(type) {
	case float64:
		return int16(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Int32() (int32, error) {
	switch v := r.value.(type) {
	case float64:
		return int32(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Int64() (int64, error) {
	switch v := r.value.(type) {
	case float64:
		return int64(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Uint() (uint, error) {
	switch v := r.value.(type) {
	case float64:
		return uint(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Uint8() (uint8, error) {
	switch v := r.value.(type) {
	case float64:
		return uint8(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Uint16() (uint16, error) {
	switch v := r.value.(type) {
	case float64:
		return uint16(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}
func (r *Result) Uint32() (uint32, error) {
	switch v := r.value.(type) {
	case float64:
		return uint32(v), nil
	default:
		return 0, fmt.Errorf(errMessage, reflect.ValueOf(r.value).Kind())
	}
}