func (m Match) Target() interface{} {
	return m.Value
}
Target return the value upon which Match will be applied.
package domain
type Function interface {
	Target() interface{}
	Arguments() []Arg
	Argument(string) Arg
	SetArgument(string, interface{}) Function
	Map(fn func(target interface{}) interface{}) Function
}
type Arg struct {
	Name  string
	Value interface{}
}
type NoMultiplex struct {
	Value interface{}
}
func (nm NoMultiplex) Argument(name string) Arg {
	return Arg{}
}
func (nm NoMultiplex) SetArgument(name string, value interface{}) Function {
	return nm
}
func (nm NoMultiplex) Target() interface{} {
	return nm.Value
}
func (nm NoMultiplex) Arguments() []Arg {
	return nil
}
func (nm NoMultiplex) Map(fn func(target interface{}) interface{}) Function {
	return NoMultiplex{Value: fn(nm.Value)}
}
type JSON struct {
	Value interface{}
}
func (j JSON) Argument(name string) Arg {
	return Arg{}
}
func (j JSON) SetArgument(name string, value interface{}) Function {
	return j
}
func (j JSON) Target() interface{} {
	return j.Value
}
func (j JSON) Arguments() []Arg {
	return nil
}
func (j JSON) Map(fn func(target interface{}) interface{}) Function {
	return JSON{Value: fn(j.Value)}
}
type Base64 struct {
	Value interface{}
}
func (b Base64) Argument(name string) Arg {
	return Arg{}
}
func (b Base64) SetArgument(name string, value interface{}) Function {
	return b
}
func (b Base64) Target() interface{} {
	return b.Value
}
func (b Base64) Arguments() []Arg {
	return nil
}
func (b Base64) Map(fn func(target interface{}) interface{}) Function {
	return Base64{Value: fn(b.Value)}
}
type Match struct {
	Value interface{}
	Arg   interface{}
	Args  []Arg
}
const MatchArgRegex = "regex"
func (m Match) Argument(name string) Arg {
	if name == MatchArgRegex {
		return m.Args[0]
	}
	return Arg{}
}
func (m Match) SetArgument(name string, argValue interface{}) Function {
	if name == MatchArgRegex {
		return Match{Value: m.Value, Args: []Arg{{Name: MatchArgRegex, Value: argValue}}}
	}
	return m
}