Source File
	github_com-pancsta-asyncmachine-go-pkg-machine.go

Belonging Package
	/pkg/integrations/yaegi/symbols

// Code generated by 'yaegi extract github.com/pancsta/asyncmachine-go/pkg/machine'. DO NOT EDIT.

package symbols

import (
	"context"
	"github.com/pancsta/asyncmachine-go/pkg/machine"
	"go/constant"
	"go/token"
	"reflect"
)

func init() {
	Symbols["github.com/pancsta/asyncmachine-go/pkg/machine/machine"] = map[string]reflect.Value{
		// function, constant and variable definitions
		"APrefix":                reflect.ValueOf(constant.MakeFromLiteral("\"_am\"", token.STRING, 0)),
		"ArgIndex":               reflect.ValueOf(machine.ArgIndex),
		"Canceled":               reflect.ValueOf(machine.Canceled),
		"Capitalize":             reflect.ValueOf(machine.Capitalize),
		"CtxKey":                 reflect.ValueOf(&machine.CtxKey).Elem(),
		"CtxToEv":                reflect.ValueOf(machine.CtxToEv),
		"EnvAmDebug":             reflect.ValueOf(constant.MakeFromLiteral("\"AM_DEBUG\"", token.STRING, 0)),
		"EnvAmDetectEval":        reflect.ValueOf(constant.MakeFromLiteral("\"AM_DETECT_EVAL\"", token.STRING, 0)),
		"EnvAmLog":               reflect.ValueOf(constant.MakeFromLiteral("\"AM_LOG\"", token.STRING, 0)),
		"EnvAmTestDbgAddr":       reflect.ValueOf(constant.MakeFromLiteral("\"AM_TEST_DBG_ADDR\"", token.STRING, 0)),
		"EnvAmTestDebug":         reflect.ValueOf(constant.MakeFromLiteral("\"AM_TEST_DEBUG\"", token.STRING, 0)),
		"EnvAmTestRunner":        reflect.ValueOf(constant.MakeFromLiteral("\"AM_TEST_RUNNER\"", token.STRING, 0)),
		"EnvAmTraceFilter":       reflect.ValueOf(constant.MakeFromLiteral("\"AM_TRACE_FILTER\"", token.STRING, 0)),
		"EnvLogLevel":            reflect.ValueOf(machine.EnvLogLevel),
		"ErrCanceled":            reflect.ValueOf(&machine.ErrCanceled).Elem(),
		"ErrDisposed":            reflect.ValueOf(&machine.ErrDisposed).Elem(),
		"ErrEvalTimeout":         reflect.ValueOf(&machine.ErrEvalTimeout).Elem(),
		"ErrHandlerTimeout":      reflect.ValueOf(&machine.ErrHandlerTimeout).Elem(),
		"ErrInvalidArgs":         reflect.ValueOf(&machine.ErrInvalidArgs).Elem(),
		"ErrNestedEval":          reflect.ValueOf(&machine.ErrNestedEval).Elem(),
		"ErrQueued":              reflect.ValueOf(&machine.ErrQueued).Elem(),
		"ErrRelation":            reflect.ValueOf(&machine.ErrRelation).Elem(),
		"ErrSchema":              reflect.ValueOf(&machine.ErrSchema).Elem(),
		"ErrStateInactive":       reflect.ValueOf(&machine.ErrStateInactive).Elem(),
		"ErrStateMissing":        reflect.ValueOf(&machine.ErrStateMissing).Elem(),
		"ErrStateUnknown":        reflect.ValueOf(&machine.ErrStateUnknown).Elem(),
		"ErrTimeout":             reflect.ValueOf(&machine.ErrTimeout).Elem(),
		"EvToCtx":                reflect.ValueOf(machine.EvToCtx),
		"Executed":               reflect.ValueOf(machine.Executed),
		"Hash":                   reflect.ValueOf(machine.Hash),
		"IndexToStates":          reflect.ValueOf(machine.IndexToStates),
		"IsActiveTick":           reflect.ValueOf(machine.IsActiveTick),
		"IsHandler":              reflect.ValueOf(machine.IsHandler),
		"IsQueued":               reflect.ValueOf(machine.IsQueued),
		"LogArgs":                reflect.ValueOf(&machine.LogArgs).Elem(),
		"LogArgsMapperMerge":     reflect.ValueOf(machine.LogArgsMapperMerge),
		"LogArgsMaxLen":          reflect.ValueOf(&machine.LogArgsMaxLen).Elem(),
		"LogChanges":             reflect.ValueOf(machine.LogChanges),
		"LogDecisions":           reflect.ValueOf(machine.LogDecisions),
		"LogEverything":          reflect.ValueOf(machine.LogEverything),
		"LogExternal":            reflect.ValueOf(machine.LogExternal),
		"LogNothing":             reflect.ValueOf(machine.LogNothing),
		"LogOps":                 reflect.ValueOf(machine.LogOps),
		"MutationAdd":            reflect.ValueOf(machine.MutationAdd),
		"MutationFormatArgs":     reflect.ValueOf(machine.MutationFormatArgs),
		"MutationRemove":         reflect.ValueOf(machine.MutationRemove),
		"MutationSet":            reflect.ValueOf(machine.MutationSet),
		"New":                    reflect.ValueOf(machine.New),
		"NewCommon":              reflect.ValueOf(machine.NewCommon),
		"NewEvent":               reflect.ValueOf(machine.NewEvent),
		"NewLastTxTracer":        reflect.ValueOf(machine.NewLastTxTracer),
		"NewLogArgsMapper":       reflect.ValueOf(machine.NewLogArgsMapper),
		"NewSubscriptionManager": reflect.ValueOf(machine.NewSubscriptionManager),
		"NewTime":                reflect.ValueOf(machine.NewTime),
		"NewTimeIndex":           reflect.ValueOf(machine.NewTimeIndex),
		"NextActive":             reflect.ValueOf(machine.NextActive),
		"NextActiveIn":           reflect.ValueOf(machine.NextActiveIn),
		"NextInactive":           reflect.ValueOf(machine.NextInactive),
		"NextInactiveIn":         reflect.ValueOf(machine.NextInactiveIn),
		"OptArgs":                reflect.ValueOf(machine.OptArgs),
		"OptCtx":                 reflect.ValueOf(machine.OptCtx),
		"OptEv":                  reflect.ValueOf(machine.OptEv),
		"OptsWithDebug":          reflect.ValueOf(machine.OptsWithDebug),
		"OptsWithTracers":        reflect.ValueOf(machine.OptsWithTracers),
		"Pass":                   reflect.ValueOf(machine.Pass),
		"PassMerge":              reflect.ValueOf(machine.PassMerge),
		"PositionAny":            reflect.ValueOf(machine.PositionAny),
		"PositionFirst":          reflect.ValueOf(machine.PositionFirst),
		"PositionLast":           reflect.ValueOf(machine.PositionLast),
		"PrefixErr":              reflect.ValueOf(constant.MakeFromLiteral("\"Err\"", token.STRING, 0)),
		"Queued":                 reflect.ValueOf(machine.Queued),
		"RelationAdd":            reflect.ValueOf(machine.RelationAdd),
		"RelationAfter":          reflect.ValueOf(machine.RelationAfter),
		"RelationRemove":         reflect.ValueOf(machine.RelationRemove),
		"RelationRequire":        reflect.ValueOf(machine.RelationRequire),
		"SAdd":                   reflect.ValueOf(machine.SAdd),
		"SRem":                   reflect.ValueOf(machine.SRem),
		"SchemaMerge":            reflect.ValueOf(machine.SchemaMerge),
		"StateAdd":               reflect.ValueOf(machine.StateAdd),
		"StateAny":               reflect.ValueOf(constant.MakeFromLiteral("\"Any\"", token.STRING, 0)),
		"StateDisposing":         reflect.ValueOf(constant.MakeFromLiteral("\"Disposing\"", token.STRING, 0)),
		"StateException":         reflect.ValueOf(constant.MakeFromLiteral("\"Exception\"", token.STRING, 0)),
		"StateHealthcheck":       reflect.ValueOf(constant.MakeFromLiteral("\"Healthcheck\"", token.STRING, 0)),
		"StateHeartbeat":         reflect.ValueOf(constant.MakeFromLiteral("\"Heartbeat\"", token.STRING, 0)),
		"StateMachineRestored":   reflect.ValueOf(constant.MakeFromLiteral("\"MachineRestored\"", token.STRING, 0)),
		"StateReady":             reflect.ValueOf(constant.MakeFromLiteral("\"Ready\"", token.STRING, 0)),
		"StateSet":               reflect.ValueOf(machine.StateSet),
		"StateStart":             reflect.ValueOf(constant.MakeFromLiteral("\"Start\"", token.STRING, 0)),
		"StatesByTag":            reflect.ValueOf(machine.StatesByTag),
		"StatesDiff":             reflect.ValueOf(machine.StatesDiff),
		"StatesEqual":            reflect.ValueOf(machine.StatesEqual),
		"StatesPrefix":           reflect.ValueOf(machine.StatesPrefix),
		"StatesShared":           reflect.ValueOf(machine.StatesShared),
		"StatesToIndex":          reflect.ValueOf(machine.StatesToIndex),
		"StatesWithPrefix":       reflect.ValueOf(machine.StatesWithPrefix),
		"StepCancel":             reflect.ValueOf(machine.StepCancel),
		"StepHandler":            reflect.ValueOf(machine.StepHandler),
		"StepRelation":           reflect.ValueOf(machine.StepRelation),
		"StepRemove":             reflect.ValueOf(machine.StepRemove),
		"StepRemoveNotActive":    reflect.ValueOf(machine.StepRemoveNotActive),
		"StepRequested":          reflect.ValueOf(machine.StepRequested),
		"StepSet":                reflect.ValueOf(machine.StepSet),
		"SuffixEnd":              reflect.ValueOf(constant.MakeFromLiteral("\"End\"", token.STRING, 0)),
		"SuffixEnter":            reflect.ValueOf(constant.MakeFromLiteral("\"Enter\"", token.STRING, 0)),
		"SuffixExit":             reflect.ValueOf(constant.MakeFromLiteral("\"Exit\"", token.STRING, 0)),
		"SuffixState":            reflect.ValueOf(constant.MakeFromLiteral("\"State\"", token.STRING, 0)),
		"TagArgsReq":             reflect.ValueOf(constant.MakeFromLiteral("\"ArgsReq\"", token.STRING, 0)),
		"TestMockClock":          reflect.ValueOf(machine.TestMockClock),

		// type definitions
		"A":                        reflect.ValueOf((*machine.A)(nil)),
		"ACheck":                   reflect.ValueOf((*machine.ACheck)(nil)),
		"AException":               reflect.ValueOf((*machine.AException)(nil)),
		"Api":                      reflect.ValueOf((*machine.Api)(nil)),
		"Args":                     reflect.ValueOf((*machine.Args)(nil)),
		"ArgsApi":                  reflect.ValueOf((*machine.ArgsApi)(nil)),
		"ArgsBase":                 reflect.ValueOf((*machine.ArgsBase)(nil)),
		"BindOpts":                 reflect.ValueOf((*machine.BindOpts)(nil)),
		"CallSignature":            reflect.ValueOf((*machine.CallSignature)(nil)),
		"Clock":                    reflect.ValueOf((*machine.Clock)(nil)),
		"CtxBinding":               reflect.ValueOf((*machine.CtxBinding)(nil)),
		"CtxKeyName":               reflect.ValueOf((*machine.CtxKeyName)(nil)),
		"CtxValue":                 reflect.ValueOf((*machine.CtxValue)(nil)),
		"DefaultRelationsResolver": reflect.ValueOf((*machine.DefaultRelationsResolver)(nil)),
		"Event":                    reflect.ValueOf((*machine.Event)(nil)),
		"ExceptionArgsPanic":       reflect.ValueOf((*machine.ExceptionArgsPanic)(nil)),
		"ExceptionHandler":         reflect.ValueOf((*machine.ExceptionHandler)(nil)),
		"HandlerChange":            reflect.ValueOf((*machine.HandlerChange)(nil)),
		"HandlerDispose":           reflect.ValueOf((*machine.HandlerDispose)(nil)),
		"HandlerError":             reflect.ValueOf((*machine.HandlerError)(nil)),
		"HandlerFinal":             reflect.ValueOf((*machine.HandlerFinal)(nil)),
		"HandlerNegotiation":       reflect.ValueOf((*machine.HandlerNegotiation)(nil)),
		"IndexStateCtx":            reflect.ValueOf((*machine.IndexStateCtx)(nil)),
		"IndexWhen":                reflect.ValueOf((*machine.IndexWhen)(nil)),
		"IndexWhenArgs":            reflect.ValueOf((*machine.IndexWhenArgs)(nil)),
		"IndexWhenTime":            reflect.ValueOf((*machine.IndexWhenTime)(nil)),
		"InternalCheckFunc":        reflect.ValueOf((*machine.InternalCheckFunc)(nil)),
		"InternalLogFunc":          reflect.ValueOf((*machine.InternalLogFunc)(nil)),
		"LastTxTracer":             reflect.ValueOf((*machine.LastTxTracer)(nil)),
		"LogArgsMapperFn":          reflect.ValueOf((*machine.LogArgsMapperFn)(nil)),
		"LogEntry":                 reflect.ValueOf((*machine.LogEntry)(nil)),
		"LogLevel":                 reflect.ValueOf((*machine.LogLevel)(nil)),
		"LoggerFn":                 reflect.ValueOf((*machine.LoggerFn)(nil)),
		"Machine":                  reflect.ValueOf((*machine.Machine)(nil)),
		"MutSource":                reflect.ValueOf((*machine.MutSource)(nil)),
		"Mutation":                 reflect.ValueOf((*machine.Mutation)(nil)),
		"MutationType":             reflect.ValueOf((*machine.MutationType)(nil)),
		"Opts":                     reflect.ValueOf((*machine.Opts)(nil)),
		"Pipe":                     reflect.ValueOf((*machine.Pipe)(nil)),
		"Position":                 reflect.ValueOf((*machine.Position)(nil)),
		"Relation":                 reflect.ValueOf((*machine.Relation)(nil)),
		"RelationsResolver":        reflect.ValueOf((*machine.RelationsResolver)(nil)),
		"Result":                   reflect.ValueOf((*machine.Result)(nil)),
		"S":                        reflect.ValueOf((*machine.S)(nil)),
		"Schema":                   reflect.ValueOf((*machine.Schema)(nil)),
		"SemConfig":                reflect.ValueOf((*machine.SemConfig)(nil)),
		"SemLogger":                reflect.ValueOf((*machine.SemLogger)(nil)),
		"Serialized":               reflect.ValueOf((*machine.Serialized)(nil)),
		"State":                    reflect.ValueOf((*machine.State)(nil)),
		"StateIsActive":            reflect.ValueOf((*machine.StateIsActive)(nil)),
		"States":                   reflect.ValueOf((*machine.States)(nil)),
		"StatesBase":               reflect.ValueOf((*machine.StatesBase)(nil)),
		"Step":                     reflect.ValueOf((*machine.Step)(nil)),
		"StepType":                 reflect.ValueOf((*machine.StepType)(nil)),
		"Subscriptions":            reflect.ValueOf((*machine.Subscriptions)(nil)),
		"Time":                     reflect.ValueOf((*machine.Time)(nil)),
		"TimeIndex":                reflect.ValueOf((*machine.TimeIndex)(nil)),
		"Tracer":                   reflect.ValueOf((*machine.Tracer)(nil)),
		"TracerNoOp":               reflect.ValueOf((*machine.TracerNoOp)(nil)),
		"Transition":               reflect.ValueOf((*machine.Transition)(nil)),
		"WhenArgsBinding":          reflect.ValueOf((*machine.WhenArgsBinding)(nil)),
		"WhenBinding":              reflect.ValueOf((*machine.WhenBinding)(nil)),
		"WhenTimeBinding":          reflect.ValueOf((*machine.WhenTimeBinding)(nil)),
		"WhenTimeSumBinding":       reflect.ValueOf((*machine.WhenTimeSumBinding)(nil)),

		// interface wrapper definitions
		"_Api":               reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_Api)(nil)),
		"_ArgsApi":           reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_ArgsApi)(nil)),
		"_RelationsResolver": reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver)(nil)),
		"_SemLogger":         reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger)(nil)),
		"_States":            reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_States)(nil)),
		"_Tracer":            reflect.ValueOf((*_github_com_pancsta_asyncmachine_go_pkg_machine_Tracer)(nil)),
	}
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_Api is an interface wrapper for Api type
type _github_com_pancsta_asyncmachine_go_pkg_machine_Api struct {
	IValue            interface{}
	WActiveStates     func(states machine.S) machine.S
	WAdd              func(states machine.S, args machine.A) machine.Result
	WAdd1             func(state string, args machine.A) machine.Result
	WAddBreakpoint    func(added machine.S, removed machine.S, strict bool)
	WAddBreakpoint1   func(added string, removed string, strict bool)
	WAddErr           func(err error, args machine.A) machine.Result
	WAddErrState      func(state string, err error, args machine.A) machine.Result
	WAny              func(states ...machine.S) bool
	WAny1             func(state ...string) bool
	WBindHandlers     func(handlers any, opts ...machine.BindOpts) (string, error)
	WBindTracer       func(tracer machine.Tracer) (string, error)
	WCanAdd           func(states machine.S, args machine.A) machine.Result
	WCanAdd1          func(state string, args machine.A) machine.Result
	WCanRemove        func(states machine.S, args machine.A) machine.Result
	WCanRemove1       func(state string, args machine.A) machine.Result
	WClock            func(states machine.S) machine.Clock
	WContext          func() context.Context
	WContextParent    func() context.Context
	WDetachHandlers   func(bindingId string) error
	WDetachTracer     func(id string) error
	WDispose          func()
	WErr              func() error
	WErrInternal      func() <-chan error
	WEvAdd            func(event *machine.Event, states machine.S, args machine.A) machine.Result
	WEvAdd1           func(event *machine.Event, state string, args machine.A) machine.Result
	WEvAddErr         func(event *machine.Event, err error, args machine.A) machine.Result
	WEvAddErrState    func(event *machine.Event, state string, err error, args machine.A) machine.Result
	WEvRemove         func(event *machine.Event, states machine.S, args machine.A) machine.Result
	WEvRemove1        func(event *machine.Event, state string, args machine.A) machine.Result
	WEvToggle         func(event *machine.Event, states machine.S, args machine.A) machine.Result
	WEvToggle1        func(event *machine.Event, state string, args machine.A) machine.Result
	WExport           func() (*machine.Serialized, machine.Schema, error)
	WGroups           func() (map[string][]int, []string)
	WHandlers         func() []string
	WHandlersBind     func(handlers any, opts ...machine.BindOpts) (string, error)
	WHandlersBindMaps func(negotiations map[string]machine.HandlerNegotiation, finals map[string]machine.HandlerFinal, opts ...machine.BindOpts) (string, error)
	WHandlersDetach   func(bindingId string) error
	WHas              func(states machine.S) bool
	WHas1             func(state string) bool
	WId               func() string
	WIndex            func(states machine.S) []int
	WIndex1           func(state string) int
	WInspect          func(states machine.S) string
	WIs               func(states machine.S) bool
	WIs1              func(state string) bool
	WIsClock          func(clock machine.Clock) bool
	WIsDisposed       func() bool
	WIsErr            func() bool
	WIsLocal          func() bool
	WIsTime           func(time machine.Time, states machine.S) bool
	WLog              func(msg string, args ...any)
	WMachineTick      func() uint32
	WNewStateCtx      func(state string, e ...*machine.Event) context.Context
	WNot              func(states machine.S) bool
	WNot1             func(state string) bool
	WOnDispose        func(fn machine.HandlerDispose)
	WParentId         func() string
	WParseStates      func(states machine.S) machine.S
	WQueueLen         func() uint16
	WQueueTick        func() uint64
	WRemove           func(states machine.S, args machine.A) machine.Result
	WRemove1          func(state string, args machine.A) machine.Result
	WSchema           func() machine.Schema
	WSemLogger        func() machine.SemLogger
	WSet              func(states machine.S, args machine.A) machine.Result
	WStateNames       func() machine.S
	WStatesVerified   func() bool
	WString           func() string
	WStringAll        func() string
	WSwitch           func(groups ...machine.S) string
	WTags             func() []string
	WTick             func(state string) uint64
	WTime             func(states machine.S) machine.Time
	WToggle           func(states machine.S, args machine.A) machine.Result
	WToggle1          func(state string, args machine.A) machine.Result
	WTracerBind       func(tracer machine.Tracer) (string, error)
	WTracerDetach     func(id string) error
	WTracers          func() []machine.Tracer
	WTransition       func() *machine.Transition
	WWasClock         func(clock machine.Clock) bool
	WWasTime          func(time machine.Time, states machine.S) bool
	WWhen             func(states machine.S, ctx context.Context) <-chan struct{}
	WWhen1            func(state string, ctx context.Context) <-chan struct{}
	WWhenArgs         func(state string, args machine.A, ctx context.Context) <-chan struct{}
	WWhenDisposed     func() <-chan struct{}
	WWhenErr          func(ctx context.Context) <-chan struct{}
	WWhenNextActive   func(state string, ctx context.Context) <-chan struct{}
	WWhenNot          func(states machine.S, ctx context.Context) <-chan struct{}
	WWhenNot1         func(state string, ctx context.Context) <-chan struct{}
	WWhenQuery        func(query func(clock machine.Clock) bool, ctx context.Context) <-chan struct{}
	WWhenQueue        func(tick machine.Result) <-chan struct{}
	WWhenTicks        func(state string, ticks int, ctx context.Context) <-chan struct{}
	WWhenTime         func(states machine.S, times machine.Time, ctx context.Context) <-chan struct{}
	WWhenTime1        func(state string, tick uint64, ctx context.Context) <-chan struct{}
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) ActiveStates(states machine.S) machine.S {
	return W.WActiveStates(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Add(states machine.S, args machine.A) machine.Result {
	return W.WAdd(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Add1(state string, args machine.A) machine.Result {
	return W.WAdd1(state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) AddBreakpoint(added machine.S, removed machine.S, strict bool) {
	W.WAddBreakpoint(added, removed, strict)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) AddBreakpoint1(added string, removed string, strict bool) {
	W.WAddBreakpoint1(added, removed, strict)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) AddErr(err error, args machine.A) machine.Result {
	return W.WAddErr(err, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) AddErrState(state string, err error, args machine.A) machine.Result {
	return W.WAddErrState(state, err, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Any(states ...machine.S) bool {
	return W.WAny(states...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Any1(state ...string) bool {
	return W.WAny1(state...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) BindHandlers(handlers any, opts ...machine.BindOpts) (string, error) {
	return W.WBindHandlers(handlers, opts...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) BindTracer(tracer machine.Tracer) (string, error) {
	return W.WBindTracer(tracer)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) CanAdd(states machine.S, args machine.A) machine.Result {
	return W.WCanAdd(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) CanAdd1(state string, args machine.A) machine.Result {
	return W.WCanAdd1(state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) CanRemove(states machine.S, args machine.A) machine.Result {
	return W.WCanRemove(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) CanRemove1(state string, args machine.A) machine.Result {
	return W.WCanRemove1(state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Clock(states machine.S) machine.Clock {
	return W.WClock(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Context() context.Context {
	return W.WContext()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) ContextParent() context.Context {
	return W.WContextParent()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) DetachHandlers(bindingId string) error {
	return W.WDetachHandlers(bindingId)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) DetachTracer(id string) error {
	return W.WDetachTracer(id)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Dispose() {
	W.WDispose()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Err() error {
	return W.WErr()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) ErrInternal() <-chan error {
	return W.WErrInternal()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvAdd(event *machine.Event, states machine.S, args machine.A) machine.Result {
	return W.WEvAdd(event, states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvAdd1(event *machine.Event, state string, args machine.A) machine.Result {
	return W.WEvAdd1(event, state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvAddErr(event *machine.Event, err error, args machine.A) machine.Result {
	return W.WEvAddErr(event, err, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvAddErrState(event *machine.Event, state string, err error, args machine.A) machine.Result {
	return W.WEvAddErrState(event, state, err, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvRemove(event *machine.Event, states machine.S, args machine.A) machine.Result {
	return W.WEvRemove(event, states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvRemove1(event *machine.Event, state string, args machine.A) machine.Result {
	return W.WEvRemove1(event, state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvToggle(event *machine.Event, states machine.S, args machine.A) machine.Result {
	return W.WEvToggle(event, states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) EvToggle1(event *machine.Event, state string, args machine.A) machine.Result {
	return W.WEvToggle1(event, state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Export() (*machine.Serialized, machine.Schema, error) {
	return W.WExport()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Groups() (map[string][]int, []string) {
	return W.WGroups()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Handlers() []string {
	return W.WHandlers()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) HandlersBind(handlers any, opts ...machine.BindOpts) (string, error) {
	return W.WHandlersBind(handlers, opts...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) HandlersBindMaps(negotiations map[string]machine.HandlerNegotiation, finals map[string]machine.HandlerFinal, opts ...machine.BindOpts) (string, error) {
	return W.WHandlersBindMaps(negotiations, finals, opts...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) HandlersDetach(bindingId string) error {
	return W.WHandlersDetach(bindingId)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Has(states machine.S) bool {
	return W.WHas(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Has1(state string) bool {
	return W.WHas1(state)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Id() string {
	return W.WId()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Index(states machine.S) []int {
	return W.WIndex(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Index1(state string) int {
	return W.WIndex1(state)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Inspect(states machine.S) string {
	return W.WInspect(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Is(states machine.S) bool {
	return W.WIs(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Is1(state string) bool {
	return W.WIs1(state)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) IsClock(clock machine.Clock) bool {
	return W.WIsClock(clock)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) IsDisposed() bool {
	return W.WIsDisposed()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) IsErr() bool {
	return W.WIsErr()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) IsLocal() bool {
	return W.WIsLocal()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) IsTime(time machine.Time, states machine.S) bool {
	return W.WIsTime(time, states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Log(msg string, args ...any) {
	W.WLog(msg, args...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) MachineTick() uint32 {
	return W.WMachineTick()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) NewStateCtx(state string, e ...*machine.Event) context.Context {
	return W.WNewStateCtx(state, e...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Not(states machine.S) bool {
	return W.WNot(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Not1(state string) bool {
	return W.WNot1(state)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) OnDispose(fn machine.HandlerDispose) {
	W.WOnDispose(fn)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) ParentId() string {
	return W.WParentId()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) ParseStates(states machine.S) machine.S {
	return W.WParseStates(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) QueueLen() uint16 {
	return W.WQueueLen()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) QueueTick() uint64 {
	return W.WQueueTick()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Remove(states machine.S, args machine.A) machine.Result {
	return W.WRemove(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Remove1(state string, args machine.A) machine.Result {
	return W.WRemove1(state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Schema() machine.Schema {
	return W.WSchema()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) SemLogger() machine.SemLogger {
	return W.WSemLogger()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Set(states machine.S, args machine.A) machine.Result {
	return W.WSet(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) StateNames() machine.S {
	return W.WStateNames()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) StatesVerified() bool {
	return W.WStatesVerified()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) String() string {
	if W.WString == nil {
		return ""
	}
	return W.WString()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) StringAll() string {
	return W.WStringAll()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Switch(groups ...machine.S) string {
	return W.WSwitch(groups...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Tags() []string {
	return W.WTags()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Tick(state string) uint64 {
	return W.WTick(state)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Time(states machine.S) machine.Time {
	return W.WTime(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Toggle(states machine.S, args machine.A) machine.Result {
	return W.WToggle(states, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Toggle1(state string, args machine.A) machine.Result {
	return W.WToggle1(state, args)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) TracerBind(tracer machine.Tracer) (string, error) {
	return W.WTracerBind(tracer)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) TracerDetach(id string) error {
	return W.WTracerDetach(id)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Tracers() []machine.Tracer {
	return W.WTracers()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) Transition() *machine.Transition {
	return W.WTransition()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WasClock(clock machine.Clock) bool {
	return W.WWasClock(clock)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WasTime(time machine.Time, states machine.S) bool {
	return W.WWasTime(time, states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) When(states machine.S, ctx context.Context) <-chan struct{} {
	return W.WWhen(states, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) When1(state string, ctx context.Context) <-chan struct{} {
	return W.WWhen1(state, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenArgs(state string, args machine.A, ctx context.Context) <-chan struct{} {
	return W.WWhenArgs(state, args, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenDisposed() <-chan struct{} {
	return W.WWhenDisposed()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenErr(ctx context.Context) <-chan struct{} {
	return W.WWhenErr(ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenNextActive(state string, ctx context.Context) <-chan struct{} {
	return W.WWhenNextActive(state, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenNot(states machine.S, ctx context.Context) <-chan struct{} {
	return W.WWhenNot(states, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenNot1(state string, ctx context.Context) <-chan struct{} {
	return W.WWhenNot1(state, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenQuery(query func(clock machine.Clock) bool, ctx context.Context) <-chan struct{} {
	return W.WWhenQuery(query, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenQueue(tick machine.Result) <-chan struct{} {
	return W.WWhenQueue(tick)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenTicks(state string, ticks int, ctx context.Context) <-chan struct{} {
	return W.WWhenTicks(state, ticks, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenTime(states machine.S, times machine.Time, ctx context.Context) <-chan struct{} {
	return W.WWhenTime(states, times, ctx)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Api) WhenTime1(state string, tick uint64, ctx context.Context) <-chan struct{} {
	return W.WWhenTime1(state, tick, ctx)
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_ArgsApi is an interface wrapper for ArgsApi type
type _github_com_pancsta_asyncmachine_go_pkg_machine_ArgsApi struct {
	IValue      interface{}
	WArgsPrefix func() string
	WArgsState  func() string
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_ArgsApi) ArgsPrefix() string {
	return W.WArgsPrefix()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_ArgsApi) ArgsState() string {
	return W.WArgsState()
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver is an interface wrapper for RelationsResolver type
type _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver struct {
	IValue              interface{}
	WInboundRelationsOf func(toState string) (machine.S, error)
	WNewAutoMutation    func() (*machine.Mutation, machine.S)
	WNewSchema          func(schema machine.Schema, states machine.S)
	WRelationsBetween   func(fromState string, toState string) ([]machine.Relation, error)
	WRelationsOf        func(fromState string) ([]machine.Relation, error)
	WSortStates         func(states machine.S)
	WTargetStates       func(t *machine.Transition, calledStates machine.S, index machine.S) machine.S
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) InboundRelationsOf(toState string) (machine.S, error) {
	return W.WInboundRelationsOf(toState)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) NewAutoMutation() (*machine.Mutation, machine.S) {
	return W.WNewAutoMutation()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) NewSchema(schema machine.Schema, states machine.S) {
	W.WNewSchema(schema, states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) RelationsBetween(fromState string, toState string) ([]machine.Relation, error) {
	return W.WRelationsBetween(fromState, toState)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) RelationsOf(fromState string) ([]machine.Relation, error) {
	return W.WRelationsOf(fromState)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) SortStates(states machine.S) {
	W.WSortStates(states)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_RelationsResolver) TargetStates(t *machine.Transition, calledStates machine.S, index machine.S) machine.S {
	return W.WTargetStates(t, calledStates, index)
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger is an interface wrapper for SemLogger type
type _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger struct {
	IValue            interface{}
	WAddPipeIn        func(isAdd bool, targetState string, sourceMach string)
	WAddPipeOut       func(isAdd bool, sourceState string, targetMach string)
	WArgsMapper       func() machine.LogArgsMapperFn
	WEnableArgs       func(val bool)
	WEnableCan        func(enable bool)
	WEnableGraph      func(enable bool)
	WEnableId         func(val bool)
	WEnableQueued     func(val bool)
	WEnableStateCtx   func(val bool)
	WEnableSteps      func(enable bool)
	WEnableWhen       func(val bool)
	WIsArgs           func() bool
	WIsCan            func() bool
	WIsGraph          func() bool
	WIsId             func() bool
	WIsQueued         func() bool
	WIsStateCtx       func() bool
	WIsSteps          func() bool
	WIsWhen           func() bool
	WLevel            func() machine.LogLevel
	WLogger           func() machine.LoggerFn
	WPipes            func() []*machine.LogEntry
	WRemovePipes      func(machId string)
	WSetArgsMapper    func(mapper machine.LogArgsMapperFn)
	WSetArgsMapperDef func(additional ...string)
	WSetEmpty         func(lvl machine.LogLevel)
	WSetLevel         func(lvl machine.LogLevel)
	WSetLogger        func(logger machine.LoggerFn)
	WSetSimple        func(logf func(format string, args ...any), level machine.LogLevel)
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) AddPipeIn(isAdd bool, targetState string, sourceMach string) {
	W.WAddPipeIn(isAdd, targetState, sourceMach)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) AddPipeOut(isAdd bool, sourceState string, targetMach string) {
	W.WAddPipeOut(isAdd, sourceState, targetMach)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) ArgsMapper() machine.LogArgsMapperFn {
	return W.WArgsMapper()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableArgs(val bool) {
	W.WEnableArgs(val)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableCan(enable bool) {
	W.WEnableCan(enable)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableGraph(enable bool) {
	W.WEnableGraph(enable)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableId(val bool) {
	W.WEnableId(val)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableQueued(val bool) {
	W.WEnableQueued(val)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableStateCtx(val bool) {
	W.WEnableStateCtx(val)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableSteps(enable bool) {
	W.WEnableSteps(enable)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) EnableWhen(val bool) {
	W.WEnableWhen(val)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsArgs() bool {
	return W.WIsArgs()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsCan() bool {
	return W.WIsCan()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsGraph() bool {
	return W.WIsGraph()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsId() bool {
	return W.WIsId()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsQueued() bool {
	return W.WIsQueued()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsStateCtx() bool {
	return W.WIsStateCtx()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsSteps() bool {
	return W.WIsSteps()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) IsWhen() bool {
	return W.WIsWhen()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) Level() machine.LogLevel {
	return W.WLevel()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) Logger() machine.LoggerFn {
	return W.WLogger()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) Pipes() []*machine.LogEntry {
	return W.WPipes()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) RemovePipes(machId string) {
	W.WRemovePipes(machId)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetArgsMapper(mapper machine.LogArgsMapperFn) {
	W.WSetArgsMapper(mapper)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetArgsMapperDef(additional ...string) {
	W.WSetArgsMapperDef(additional...)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetEmpty(lvl machine.LogLevel) {
	W.WSetEmpty(lvl)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetLevel(lvl machine.LogLevel) {
	W.WSetLevel(lvl)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetLogger(logger machine.LoggerFn) {
	W.WSetLogger(logger)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_SemLogger) SetSimple(logf func(format string, args ...any), level machine.LogLevel) {
	W.WSetSimple(logf, level)
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_States is an interface wrapper for States type
type _github_com_pancsta_asyncmachine_go_pkg_machine_States struct {
	IValue          interface{}
	WNames          func() machine.S
	WSetNames       func(a0 machine.S)
	WSetStateGroups func(a0 map[string][]int, a1 []string)
	WStateGroups    func() (map[string][]int, []string)
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_States) Names() machine.S {
	return W.WNames()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_States) SetNames(a0 machine.S) {
	W.WSetNames(a0)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_States) SetStateGroups(a0 map[string][]int, a1 []string) {
	W.WSetStateGroups(a0, a1)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_States) StateGroups() (map[string][]int, []string) {
	return W.WStateGroups()
}

// _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer is an interface wrapper for Tracer type
type _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer struct {
	IValue            interface{}
	WHandlerEnd       func(transition *machine.Transition, emitter string, handler string)
	WHandlerStart     func(transition *machine.Transition, emitter string, handler string)
	WInheritable      func() bool
	WMachineDispose   func(machID string)
	WMachineInit      func(machine machine.Api) context.Context
	WMutationQueued   func(machine machine.Api, mutation *machine.Mutation)
	WNewSubmachine    func(parent machine.Api, machine machine.Api)
	WQueueEnd         func(machine machine.Api)
	WSchemaChange     func(machine machine.Api, old machine.Schema)
	WTracerId         func() string
	WTransitionEnd    func(transition *machine.Transition)
	WTransitionFinals func(transition *machine.Transition)
	WTransitionInit   func(transition *machine.Transition)
	WTransitionStart  func(transition *machine.Transition)
	WVerifyStates     func(machine machine.Api)
}

func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) HandlerEnd(transition *machine.Transition, emitter string, handler string) {
	W.WHandlerEnd(transition, emitter, handler)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) HandlerStart(transition *machine.Transition, emitter string, handler string) {
	W.WHandlerStart(transition, emitter, handler)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) Inheritable() bool {
	return W.WInheritable()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) MachineDispose(machID string) {
	W.WMachineDispose(machID)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) MachineInit(machine machine.Api) context.Context {
	return W.WMachineInit(machine)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) MutationQueued(machine machine.Api, mutation *machine.Mutation) {
	W.WMutationQueued(machine, mutation)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) NewSubmachine(parent machine.Api, machine machine.Api) {
	W.WNewSubmachine(parent, machine)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) QueueEnd(machine machine.Api) {
	W.WQueueEnd(machine)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) SchemaChange(machine machine.Api, old machine.Schema) {
	W.WSchemaChange(machine, old)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) TracerId() string {
	return W.WTracerId()
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) TransitionEnd(transition *machine.Transition) {
	W.WTransitionEnd(transition)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) TransitionFinals(transition *machine.Transition) {
	W.WTransitionFinals(transition)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) TransitionInit(transition *machine.Transition) {
	W.WTransitionInit(transition)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) TransitionStart(transition *machine.Transition) {
	W.WTransitionStart(transition)
}
func (W _github_com_pancsta_asyncmachine_go_pkg_machine_Tracer) VerifyStates(machine machine.Api) {
	W.WVerifyStates(machine)
}

The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.