func ResolveExmplRootMessageInput(ctx context.Context, i interface{}) (_ *testdata_1.RootMessage, rerr error) {
	if i == nil {
		return nil, nil
	}
	args := i.(map[string]interface{})
	_ = args
	var result = new(testdata_1.RootMessage)
	if args["r_msg"] != nil {
		in := args["r_msg"].([]interface{})
		result.RMsg = make([]*testdata_1.RootMessage_NestedMessage, len(in))
		for i, val := range in {
			{
				v, err := ResolveExmplRootMessageNestedMessageInput(ctx, val)
				if err != nil {
					return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
				}
				result.RMsg[i] = v
			}
		}
	}
	if args["r_scalar"] != nil {
		in := args["r_scalar"].([]interface{})
		result.RScalar = make([]int32, len(in))
		for i, val := range in {
			result.RScalar[i] = val.(int32)
		}
	}
	if args["r_enum"] != nil {
		in := args["r_enum"].([]interface{})
		result.REnum = make([]testdata_1.RootEnum, len(in))
		for i, val := range in {
			result.REnum[i] = testdata_1.RootEnum(val.(int))
		}
	}
	if args["r_empty_msg"] != nil {
		in := args["r_empty_msg"].([]interface{})
		result.REmptyMsg = make([]*testdata_1.Empty, len(in))
		for i, val := range in {
			{
				v, err := ResolveExmplEmptyInput(ctx, val)
				if err != nil {
					return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
				}
				result.REmptyMsg[i] = v
			}
		}
	}
	if args["n_r_enum"] != nil {
		result.NREnum = common_1.CommonEnum(args["n_r_enum"].(int))
	}
	if args["n_r_scalar"] != nil {
		result.NRScalar = args["n_r_scalar"].(int32)
	}
	if args["n_r_msg"] != nil {
		{
			v, err := common.ResolveCommonMessageInput(ctx, args["n_r_msg"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.NRMsg = v
		}
	}
	{
		v, err := func() (val int32, err error) {
			contextValue := ctx.Value("ctx_key")
			if contextValue == nil {
				err = errors.New("Can't find key 'ctx_key' in context")
				return
			}
			val, ok := contextValue.(int32)
			if !ok {
				err = errors.New("Incompatible 'ctx_key' key type in context. Expected int32")
				return
			}
			return
		}()
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
		}
		result.ScalarFromContext = v
	}
	if args["n_r_empty_msg"] != nil {
		{
			v, err := ResolveExmplEmptyInput(ctx, args["n_r_empty_msg"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.NREmptyMsg = v
		}
	}
	if args["leading_dot"] != nil {
		{
			v, err := common.ResolveCommonMessageInput(ctx, args["leading_dot"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.LeadingDot = v
		}
	}
	if args["parent_scope"] != nil {
		result.ParentScope = testdata_1.ParentScopeEnum(args["parent_scope"].(int))
	}
	if args["proto2message"] != nil {
		{
			v, err := common.ResolveProto2MessageInput(ctx, args["proto2message"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.Proto2Message = v
		}
	}
	if args["map_enum"] != nil {
		{
			v, err := ResolveExmplRootMessageInput__MapEnum(ctx, args["map_enum"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.MapEnum = v
		}
	}
	if args["map_scalar"] != nil {
		{
			v, err := ResolveExmplRootMessageInput__MapScalar(ctx, args["map_scalar"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.MapScalar = v
		}
	}
	if args["map_msg"] != nil {
		{
			v, err := ResolveExmplRootMessageInput__MapMsg(ctx, args["map_msg"])
			if err != nil {
				return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
			}
			result.MapMsg = v
		}
	}
	{
		v, err := func() (val map[string]*testdata_1.RootMessage_NestedMessage, err error) {
			contextValue := ctx.Value("ctx_map")
			if contextValue == nil {
				err = errors.New("Can't find key 'ctx_map' in context")
				return
			}
			val, ok := contextValue.(map[string]*testdata_1.RootMessage_NestedMessage)
			if !ok {
				err = errors.New("Incompatible 'ctx_map' key type in context. Expected map[string]*testdata_1.RootMessage_NestedMessage")
				return
			}
			return
		}()
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
		}
		result.CtxMap = v
	}
	{
		v, err := func() (val map[string]testdata_1.RootMessage_NestedEnum, err error) {
			contextValue := ctx.Value("ctx_map_enum")
			if contextValue == nil {
				err = errors.New("Can't find key 'ctx_map_enum' in context")
				return
			}
			val, ok := contextValue.(map[string]testdata_1.RootMessage_NestedEnum)
			if !ok {
				err = errors.New("Incompatible 'ctx_map_enum' key type in context. Expected map[string]testdata_1.RootMessage_NestedEnum")
				return
			}
			return
		}()
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve `ResolveExmplRootMessageInput` input object field")
		}
		result.CtxMapEnum = v
	}
	if e_f_o_e_, ok := args["e_f_o_e"]; ok && e_f_o_e_ != nil {
		v := common_1.CommonEnum(e_f_o_e_.(int))
		result.EnumFirstOneoff = &testdata_1.RootMessage_EFOE{v}
	} else if e_f_o_s_, ok := args["e_f_o_s"]; ok && e_f_o_s_ != nil {
		v := e_f_o_s_.(int32)
		result.EnumFirstOneoff = &testdata_1.RootMessage_EFOS{v}
	} else if e_f_o_m_, ok := args["e_f_o_m"]; ok && e_f_o_m_ != nil {
		v, err := common.ResolveCommonMessageInput(ctx, e_f_o_m_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field e_f_o_m")
		}
		result.EnumFirstOneoff = &testdata_1.RootMessage_EFOM{v}
	} else if e_f_o_em_, ok := args["e_f_o_em"]; ok && e_f_o_em_ != nil {
		v, err := ResolveExmplEmptyInput(ctx, e_f_o_em_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field e_f_o_em")
		}
		result.EnumFirstOneoff = &testdata_1.RootMessage_EFOEm{v}
	}
	if s_f_o_s_, ok := args["s_f_o_s"]; ok && s_f_o_s_ != nil {
		v := s_f_o_s_.(int32)
		result.ScalarFirstOneoff = &testdata_1.RootMessage_SFOS{v}
	} else if s_f_o_e_, ok := args["s_f_o_e"]; ok && s_f_o_e_ != nil {
		v := testdata_1.RootEnum(s_f_o_e_.(int))
		result.ScalarFirstOneoff = &testdata_1.RootMessage_SFOE{v}
	} else if s_f_o_mes_, ok := args["s_f_o_mes"]; ok && s_f_o_mes_ != nil {
		v, err := ResolveExmplRootMessage2Input(ctx, s_f_o_mes_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field s_f_o_mes")
		}
		result.ScalarFirstOneoff = &testdata_1.RootMessage_SFOMes{v}
	} else if s_f_o_m_, ok := args["s_f_o_m"]; ok && s_f_o_m_ != nil {
		v, err := ResolveExmplEmptyInput(ctx, s_f_o_m_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field s_f_o_m")
		}
		result.ScalarFirstOneoff = &testdata_1.RootMessage_SFOM{v}
	}
	if m_f_o_m_, ok := args["m_f_o_m"]; ok && m_f_o_m_ != nil {
		v, err := ResolveExmplRootMessage2Input(ctx, m_f_o_m_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field m_f_o_m")
		}
		result.MessageFirstOneoff = &testdata_1.RootMessage_MFOM{v}
	} else if m_f_o_s_, ok := args["m_f_o_s"]; ok && m_f_o_s_ != nil {
		v := m_f_o_s_.(int32)
		result.MessageFirstOneoff = &testdata_1.RootMessage_MFOS{v}
	} else if m_f_o_e_, ok := args["m_f_o_e"]; ok && m_f_o_e_ != nil {
		v := testdata_1.RootEnum(m_f_o_e_.(int))
		result.MessageFirstOneoff = &testdata_1.RootMessage_MFOE{v}
	} else if m_f_o_em_, ok := args["m_f_o_em"]; ok && m_f_o_em_ != nil {
		v, err := ResolveExmplEmptyInput(ctx, m_f_o_em_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field m_f_o_em")
		}
		result.MessageFirstOneoff = &testdata_1.RootMessage_MFOEm{v}
	}
	if em_f_o_em_, ok := args["em_f_o_em"]; ok && em_f_o_em_ != nil {
		v, err := ResolveExmplEmptyInput(ctx, em_f_o_em_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field em_f_o_em")
		}
		result.EmptyFirstOneoff = &testdata_1.RootMessage_EmFOEm{v}
	} else if em_f_o_s_, ok := args["em_f_o_s"]; ok && em_f_o_s_ != nil {
		v := em_f_o_s_.(int32)
		result.EmptyFirstOneoff = &testdata_1.RootMessage_EmFOS{v}
	} else if em_f_o_en_, ok := args["em_f_o_en"]; ok && em_f_o_en_ != nil {
		v := testdata_1.RootEnum(em_f_o_en_.(int))
		result.EmptyFirstOneoff = &testdata_1.RootMessage_EmFOEn{v}
	} else if em_f_o_m_, ok := args["em_f_o_m"]; ok && em_f_o_m_ != nil {
		v, err := ResolveExmplRootMessage2Input(ctx, em_f_o_m_)
		if err != nil {
			return nil, errors.Wrap(err, "failed to resolve oneOf object field em_f_o_m")
		}
		result.EmptyFirstOneoff = &testdata_1.RootMessage_EmFOM{v}
	}
	return result, nil
}
Input objects resolvers
package test
import (
	context "context"
	fmt "fmt"
	interceptors "github.com/EGT-Ukraine/go2gql/api/interceptors"
	scalars "github.com/EGT-Ukraine/go2gql/api/scalars"
	testdata_1 "github.com/EGT-Ukraine/go2gql/testdata"
	common_1 "github.com/EGT-Ukraine/go2gql/testdata/common"
	testdata "github.com/EGT-Ukraine/go2gql/testdata/out/test/github.com/EGT-Ukraine/go2gql/testdata"
	common "github.com/EGT-Ukraine/go2gql/testdata/out/test/github.com/EGT-Ukraine/go2gql/testdata/common"
	graphql "github.com/graphql-go/graphql"
	opentracing_go "github.com/opentracing/opentracing-go"
	log "github.com/opentracing/opentracing-go/log"
	errors "github.com/pkg/errors"
)
var ExmplRootEnum = graphql.NewEnum(graphql.EnumConfig{
	Name:        "ExmplRootEnum",
	Description: "",
	Values: graphql.EnumValueConfigMap{
		"RootEnumVal0": &graphql.EnumValueConfig{
			Value: 0,
		},
		"RootEnumVal1": &graphql.EnumValueConfig{
			Value: 1,
		},
		"RootEnumVal2": &graphql.EnumValueConfig{
			Value:       2,
			Description: "It's a RootEnumVal2",
		},
	},
})
var ExmplRootMessageNestedEnum = graphql.NewEnum(graphql.EnumConfig{
	Name:        "ExmplRootMessageNestedEnum",
	Description: "",
	Values: graphql.EnumValueConfigMap{
		"NestedEnumVal0": &graphql.EnumValueConfig{
			Value: 0,
		},
		"NestedEnumVal1": &graphql.EnumValueConfig{
			Value: 1,
		},
	},
})
var ExmplRootMessageNestedMessageNestedNestedEnum = graphql.NewEnum(graphql.EnumConfig{
	Name:        "ExmplRootMessageNestedMessageNestedNestedEnum",
	Description: "",
	Values: graphql.EnumValueConfigMap{
		"NestedNestedEnumVal0": &graphql.EnumValueConfig{
			Value: 0,
		},
		"NestedNestedEnumVal1": &graphql.EnumValueConfig{
			Value: 1,
		},
		"NestedNestedEnumVal2": &graphql.EnumValueConfig{
			Value: 2,
		},
		"NestedNestedEnumVal3": &graphql.EnumValueConfig{
			Value: 3,
		},
	},
})
var ExmplRootMessageInput = graphql.NewInputObject(graphql.InputObjectConfig{
	Name:   "ExmplRootMessageInput",
	Fields: graphql.InputObjectConfigFieldMap{},
})
func init() {
	ExmplRootMessageInput.Fields()["r_msg"] = &graphql.InputObjectField{PrivateName: "r_msg", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessage_NestedMessageInput))}
	ExmplRootMessageInput.Fields()["r_scalar"] = &graphql.InputObjectField{PrivateName: "r_scalar", Type: graphql.NewList(graphql.NewNonNull(scalars.GraphQLInt32Scalar))}
	ExmplRootMessageInput.Fields()["r_enum"] = &graphql.InputObjectField{PrivateName: "r_enum", Type: graphql.NewList(graphql.NewNonNull(ExmplRootEnum))}
	ExmplRootMessageInput.Fields()["r_empty_msg"] = &graphql.InputObjectField{PrivateName: "r_empty_msg", Type: graphql.NewList(graphql.NewNonNull(scalars.NoDataScalar))}
	ExmplRootMessageInput.Fields()["n_r_enum"] = &graphql.InputObjectField{PrivateName: "n_r_enum", Type: common.CommonEnum}
	ExmplRootMessageInput.Fields()["n_r_scalar"] = &graphql.InputObjectField{PrivateName: "n_r_scalar", Type: scalars.GraphQLInt32Scalar}
	ExmplRootMessageInput.Fields()["n_r_msg"] = &graphql.InputObjectField{PrivateName: "n_r_msg", Type: common.CommonMessageInput}
	ExmplRootMessageInput.Fields()["n_r_empty_msg"] = &graphql.InputObjectField{PrivateName: "n_r_empty_msg", Type: scalars.NoDataScalar}
	ExmplRootMessageInput.Fields()["leading_dot"] = &graphql.InputObjectField{PrivateName: "leading_dot", Type: common.CommonMessageInput}
	ExmplRootMessageInput.Fields()["parent_scope"] = &graphql.InputObjectField{PrivateName: "parent_scope", Type: testdata.ParentScopeEnum}
	ExmplRootMessageInput.Fields()["proto2message"] = &graphql.InputObjectField{PrivateName: "proto2message", Type: common.Proto2MessageInput}
	ExmplRootMessageInput.Fields()["map_enum"] = &graphql.InputObjectField{PrivateName: "map_enum", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageInput__MapEnum))}
	ExmplRootMessageInput.Fields()["map_scalar"] = &graphql.InputObjectField{PrivateName: "map_scalar", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageInput__MapScalar))}
	ExmplRootMessageInput.Fields()["map_msg"] = &graphql.InputObjectField{PrivateName: "map_msg", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageInput__MapMsg))}
	ExmplRootMessageInput.Fields()["ctx_map"] = &graphql.InputObjectField{PrivateName: "ctx_map", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageInput__CtxMap))}
	ExmplRootMessageInput.Fields()["ctx_map_enum"] = &graphql.InputObjectField{PrivateName: "ctx_map_enum", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageInput__CtxMapEnum))}
	ExmplRootMessageInput.Fields()["e_f_o_e"] = &graphql.InputObjectField{PrivateName: "e_f_o_e", Type: common.CommonEnum}
	ExmplRootMessageInput.Fields()["e_f_o_s"] = &graphql.InputObjectField{PrivateName: "e_f_o_s", Type: scalars.GraphQLInt32Scalar}
	ExmplRootMessageInput.Fields()["e_f_o_m"] = &graphql.InputObjectField{PrivateName: "e_f_o_m", Type: common.CommonMessageInput}
	ExmplRootMessageInput.Fields()["e_f_o_em"] = &graphql.InputObjectField{PrivateName: "e_f_o_em", Type: scalars.NoDataScalar}
	ExmplRootMessageInput.Fields()["s_f_o_s"] = &graphql.InputObjectField{PrivateName: "s_f_o_s", Type: scalars.GraphQLInt32Scalar}
	ExmplRootMessageInput.Fields()["s_f_o_e"] = &graphql.InputObjectField{PrivateName: "s_f_o_e", Type: ExmplRootEnum}
	ExmplRootMessageInput.Fields()["s_f_o_mes"] = &graphql.InputObjectField{PrivateName: "s_f_o_mes", Type: ExmplRootMessage2Input}
	ExmplRootMessageInput.Fields()["s_f_o_m"] = &graphql.InputObjectField{PrivateName: "s_f_o_m", Type: scalars.NoDataScalar}
	ExmplRootMessageInput.Fields()["m_f_o_m"] = &graphql.InputObjectField{PrivateName: "m_f_o_m", Type: ExmplRootMessage2Input}
	ExmplRootMessageInput.Fields()["m_f_o_s"] = &graphql.InputObjectField{PrivateName: "m_f_o_s", Type: scalars.GraphQLInt32Scalar}
	ExmplRootMessageInput.Fields()["m_f_o_e"] = &graphql.InputObjectField{PrivateName: "m_f_o_e", Type: ExmplRootEnum}
	ExmplRootMessageInput.Fields()["m_f_o_em"] = &graphql.InputObjectField{PrivateName: "m_f_o_em", Type: scalars.NoDataScalar}
	ExmplRootMessageInput.Fields()["em_f_o_em"] = &graphql.InputObjectField{PrivateName: "em_f_o_em", Type: scalars.NoDataScalar}
	ExmplRootMessageInput.Fields()["em_f_o_s"] = &graphql.InputObjectField{PrivateName: "em_f_o_s", Type: scalars.GraphQLInt32Scalar}
	ExmplRootMessageInput.Fields()["em_f_o_en"] = &graphql.InputObjectField{PrivateName: "em_f_o_en", Type: ExmplRootEnum}
	ExmplRootMessageInput.Fields()["em_f_o_m"] = &graphql.InputObjectField{PrivateName: "em_f_o_m", Type: ExmplRootMessage2Input}
}
var ExmplRootMessage_NestedMessageInput = graphql.NewInputObject(graphql.InputObjectConfig{
	Name:   "ExmplRootMessageNestedMessageInput",
	Fields: graphql.InputObjectConfigFieldMap{},
})
func init() {
	ExmplRootMessage_NestedMessageInput.Fields()["sub_r_enum"] = &graphql.InputObjectField{PrivateName: "sub_r_enum", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageNestedEnum))}
	ExmplRootMessage_NestedMessageInput.Fields()["sub_sub_r_enum"] = &graphql.InputObjectField{PrivateName: "sub_sub_r_enum", Type: graphql.NewList(graphql.NewNonNull(ExmplRootMessageNestedMessageNestedNestedEnum))}
}
var ExmplMessageWithEmptyInput = graphql.NewInputObject(graphql.InputObjectConfig{
	Name:   "ExmplMessageWithEmptyInput",
	Fields: graphql.InputObjectConfigFieldMap{},
})
func init() {
	ExmplMessageWithEmptyInput.Fields()["empt"] = &graphql.InputObjectField{PrivateName: "empt", Type: scalars.NoDataScalar}
}
var ExmplRootMessage2Input = graphql.NewInputObject(graphql.InputObjectConfig{
	Name:   "ExmplRootMessage2Input",
	Fields: graphql.InputObjectConfigFieldMap{},
})
func init() {
	ExmplRootMessage2Input.Fields()["some_field"] = &graphql.InputObjectField{PrivateName: "some_field", Type: scalars.GraphQLInt32Scalar}
}