func (f Flatten) Arguments() []Arg {
	return nil
}
Arguments return the arguments provided to Flatten function
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
}
func (m Match) Target() interface{} {
	return m.Value
}
func (m Match) Arguments() []Arg {
	return m.Args
}
func (m Match) Map(fn func(target interface{}) interface{}) Function {
	return Match{Value: fn(m.Value), Args: m.Args}
}
type AsBody struct {
	Value interface{}
}
func (ab AsBody) Argument(name string) Arg {
	return Arg{}
}
func (ab AsBody) SetArgument(name string, value interface{}) Function {
	return ab
}
func (ab AsBody) Target() interface{} {
	return ab.Value
}
func (ab AsBody) Arguments() []Arg {
	return nil
}
func (ab AsBody) Map(fn func(target interface{}) interface{}) Function {
	return AsBody{Value: fn(ab.Value)}
}
type Flatten struct {
	Value interface{}
}
func (f Flatten) Argument(name string) Arg {
	return Arg{}
}
func (f Flatten) SetArgument(name string, value interface{}) Function {
	return f
}
func (f Flatten) Target() interface{} {
	return f.Value
}