How to use marshalOBoolean2bool method of generated Package

...300	var err error301	args := map[string]interface{}{}302	var arg0 bool303	if tmp, ok := rawArgs["includeDeprecated"]; ok {304		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)305		if err != nil {306			return nil, err307		}308	}309	args["includeDeprecated"] = arg0310	return args, nil311}312func (ec *executionContext) field___Type_fields_args(ctx context.Context, rawArgs map[string]interface{}) (map[string]interface{}, error) {313	var err error314	args := map[string]interface{}{}315	var arg0 bool316	if tmp, ok := rawArgs["includeDeprecated"]; ok {317		arg0, err = ec.unmarshalOBoolean2bool(ctx, tmp)318		if err != nil {319			return nil, err320		}321	}322	args["includeDeprecated"] = arg0323	return args, nil324}325// endregion ***************************** args.gotpl *****************************326// region    ************************** directives.gotpl **************************327// endregion ************************** directives.gotpl **************************328// region    **************************** field.gotpl *****************************329func (ec *executionContext) _Inventory_salePrice(ctx context.Context, field graphql.CollectedField, obj *models.Inventory) (ret graphql.Marshaler) {330	ctx = ec.Tracer.StartFieldExecution(ctx, field)331	defer func() {332		if r := recover(); r != nil {333			ec.Error(ctx, ec.Recover(ctx, r))334			ret = graphql.Null335		}336		ec.Tracer.EndFieldExecution(ctx)337	}()338	rctx := &graphql.ResolverContext{339		Object:   "Inventory",340		Field:    field,341		Args:     nil,342		IsMethod: false,343	}344	ctx = graphql.WithResolverContext(ctx, rctx)345	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)346	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {347		ctx = rctx // use context from middleware stack in children348		return obj.SalePrice, nil349	})350	if err != nil {351		ec.Error(ctx, err)352		return graphql.Null353	}354	if resTmp == nil {355		return graphql.Null356	}357	res := resTmp.(*models.Price)358	rctx.Result = res359	ctx = ec.Tracer.StartFieldChildExecution(ctx)360	return ec.marshalOPrice2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐPrice(ctx, field.Selections, res)361}362func (ec *executionContext) _Inventory_sellOnGoogleQuantity(ctx context.Context, field graphql.CollectedField, obj *models.Inventory) (ret graphql.Marshaler) {363	ctx = ec.Tracer.StartFieldExecution(ctx, field)364	defer func() {365		if r := recover(); r != nil {366			ec.Error(ctx, ec.Recover(ctx, r))367			ret = graphql.Null368		}369		ec.Tracer.EndFieldExecution(ctx)370	}()371	rctx := &graphql.ResolverContext{372		Object:   "Inventory",373		Field:    field,374		Args:     nil,375		IsMethod: false,376	}377	ctx = graphql.WithResolverContext(ctx, rctx)378	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)379	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {380		ctx = rctx // use context from middleware stack in children381		return obj.SellOnGoogleQuantity, nil382	})383	if err != nil {384		ec.Error(ctx, err)385		return graphql.Null386	}387	if resTmp == nil {388		return graphql.Null389	}390	res := resTmp.(*string)391	rctx.Result = res392	ctx = ec.Tracer.StartFieldChildExecution(ctx)393	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)394}395func (ec *executionContext) _Inventory_availability(ctx context.Context, field graphql.CollectedField, obj *models.Inventory) (ret graphql.Marshaler) {396	ctx = ec.Tracer.StartFieldExecution(ctx, field)397	defer func() {398		if r := recover(); r != nil {399			ec.Error(ctx, ec.Recover(ctx, r))400			ret = graphql.Null401		}402		ec.Tracer.EndFieldExecution(ctx)403	}()404	rctx := &graphql.ResolverContext{405		Object:   "Inventory",406		Field:    field,407		Args:     nil,408		IsMethod: false,409	}410	ctx = graphql.WithResolverContext(ctx, rctx)411	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)412	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {413		ctx = rctx // use context from middleware stack in children414		return obj.Availability, nil415	})416	if err != nil {417		ec.Error(ctx, err)418		return graphql.Null419	}420	if resTmp == nil {421		return graphql.Null422	}423	res := resTmp.(*int)424	rctx.Result = res425	ctx = ec.Tracer.StartFieldChildExecution(ctx)426	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)427}428func (ec *executionContext) _Inventory_kind(ctx context.Context, field graphql.CollectedField, obj *models.Inventory) (ret graphql.Marshaler) {429	ctx = ec.Tracer.StartFieldExecution(ctx, field)430	defer func() {431		if r := recover(); r != nil {432			ec.Error(ctx, ec.Recover(ctx, r))433			ret = graphql.Null434		}435		ec.Tracer.EndFieldExecution(ctx)436	}()437	rctx := &graphql.ResolverContext{438		Object:   "Inventory",439		Field:    field,440		Args:     nil,441		IsMethod: false,442	}443	ctx = graphql.WithResolverContext(ctx, rctx)444	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)445	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {446		ctx = rctx // use context from middleware stack in children447		return obj.Kind, nil448	})449	if err != nil {450		ec.Error(ctx, err)451		return graphql.Null452	}453	if resTmp == nil {454		return graphql.Null455	}456	res := resTmp.(*string)457	rctx.Result = res458	ctx = ec.Tracer.StartFieldChildExecution(ctx)459	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)460}461func (ec *executionContext) _Inventory_price(ctx context.Context, field graphql.CollectedField, obj *models.Inventory) (ret graphql.Marshaler) {462	ctx = ec.Tracer.StartFieldExecution(ctx, field)463	defer func() {464		if r := recover(); r != nil {465			ec.Error(ctx, ec.Recover(ctx, r))466			ret = graphql.Null467		}468		ec.Tracer.EndFieldExecution(ctx)469	}()470	rctx := &graphql.ResolverContext{471		Object:   "Inventory",472		Field:    field,473		Args:     nil,474		IsMethod: false,475	}476	ctx = graphql.WithResolverContext(ctx, rctx)477	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)478	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {479		ctx = rctx // use context from middleware stack in children480		return obj.Price, nil481	})482	if err != nil {483		ec.Error(ctx, err)484		return graphql.Null485	}486	if resTmp == nil {487		return graphql.Null488	}489	res := resTmp.(*models.Price)490	rctx.Result = res491	ctx = ec.Tracer.StartFieldChildExecution(ctx)492	return ec.marshalOPrice2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐPrice(ctx, field.Selections, res)493}494func (ec *executionContext) _Item_inventory(ctx context.Context, field graphql.CollectedField, obj *models.Item) (ret graphql.Marshaler) {495	ctx = ec.Tracer.StartFieldExecution(ctx, field)496	defer func() {497		if r := recover(); r != nil {498			ec.Error(ctx, ec.Recover(ctx, r))499			ret = graphql.Null500		}501		ec.Tracer.EndFieldExecution(ctx)502	}()503	rctx := &graphql.ResolverContext{504		Object:   "Item",505		Field:    field,506		Args:     nil,507		IsMethod: false,508	}509	ctx = graphql.WithResolverContext(ctx, rctx)510	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)511	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {512		ctx = rctx // use context from middleware stack in children513		return obj.Inventory, nil514	})515	if err != nil {516		ec.Error(ctx, err)517		return graphql.Null518	}519	if resTmp == nil {520		return graphql.Null521	}522	res := resTmp.(*models.Inventory)523	rctx.Result = res524	ctx = ec.Tracer.StartFieldChildExecution(ctx)525	return ec.marshalOInventory2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐInventory(ctx, field.Selections, res)526}527func (ec *executionContext) _Item_productId(ctx context.Context, field graphql.CollectedField, obj *models.Item) (ret graphql.Marshaler) {528	ctx = ec.Tracer.StartFieldExecution(ctx, field)529	defer func() {530		if r := recover(); r != nil {531			ec.Error(ctx, ec.Recover(ctx, r))532			ret = graphql.Null533		}534		ec.Tracer.EndFieldExecution(ctx)535	}()536	rctx := &graphql.ResolverContext{537		Object:   "Item",538		Field:    field,539		Args:     nil,540		IsMethod: false,541	}542	ctx = graphql.WithResolverContext(ctx, rctx)543	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)544	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {545		ctx = rctx // use context from middleware stack in children546		return obj.ProductID, nil547	})548	if err != nil {549		ec.Error(ctx, err)550		return graphql.Null551	}552	if resTmp == nil {553		return graphql.Null554	}555	res := resTmp.(*string)556	rctx.Result = res557	ctx = ec.Tracer.StartFieldChildExecution(ctx)558	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)559}560func (ec *executionContext) _Item_storeCode(ctx context.Context, field graphql.CollectedField, obj *models.Item) (ret graphql.Marshaler) {561	ctx = ec.Tracer.StartFieldExecution(ctx, field)562	defer func() {563		if r := recover(); r != nil {564			ec.Error(ctx, ec.Recover(ctx, r))565			ret = graphql.Null566		}567		ec.Tracer.EndFieldExecution(ctx)568	}()569	rctx := &graphql.ResolverContext{570		Object:   "Item",571		Field:    field,572		Args:     nil,573		IsMethod: false,574	}575	ctx = graphql.WithResolverContext(ctx, rctx)576	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)577	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {578		ctx = rctx // use context from middleware stack in children579		return obj.StoreCode, nil580	})581	if err != nil {582		ec.Error(ctx, err)583		return graphql.Null584	}585	if resTmp == nil {586		return graphql.Null587	}588	res := resTmp.(*string)589	rctx.Result = res590	ctx = ec.Tracer.StartFieldChildExecution(ctx)591	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)592}593func (ec *executionContext) _LineItem_item(ctx context.Context, field graphql.CollectedField, obj *models.LineItem) (ret graphql.Marshaler) {594	ctx = ec.Tracer.StartFieldExecution(ctx, field)595	defer func() {596		if r := recover(); r != nil {597			ec.Error(ctx, ec.Recover(ctx, r))598			ret = graphql.Null599		}600		ec.Tracer.EndFieldExecution(ctx)601	}()602	rctx := &graphql.ResolverContext{603		Object:   "LineItem",604		Field:    field,605		Args:     nil,606		IsMethod: false,607	}608	ctx = graphql.WithResolverContext(ctx, rctx)609	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)610	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {611		ctx = rctx // use context from middleware stack in children612		return obj.Item, nil613	})614	if err != nil {615		ec.Error(ctx, err)616		return graphql.Null617	}618	if resTmp == nil {619		return graphql.Null620	}621	res := resTmp.(*models.Item)622	rctx.Result = res623	ctx = ec.Tracer.StartFieldChildExecution(ctx)624	return ec.marshalOItem2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐItem(ctx, field.Selections, res)625}626func (ec *executionContext) _LineItem_quantity(ctx context.Context, field graphql.CollectedField, obj *models.LineItem) (ret graphql.Marshaler) {627	ctx = ec.Tracer.StartFieldExecution(ctx, field)628	defer func() {629		if r := recover(); r != nil {630			ec.Error(ctx, ec.Recover(ctx, r))631			ret = graphql.Null632		}633		ec.Tracer.EndFieldExecution(ctx)634	}()635	rctx := &graphql.ResolverContext{636		Object:   "LineItem",637		Field:    field,638		Args:     nil,639		IsMethod: false,640	}641	ctx = graphql.WithResolverContext(ctx, rctx)642	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)643	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {644		ctx = rctx // use context from middleware stack in children645		return obj.Quantity, nil646	})647	if err != nil {648		ec.Error(ctx, err)649		return graphql.Null650	}651	if resTmp == nil {652		return graphql.Null653	}654	res := resTmp.(*int)655	rctx.Result = res656	ctx = ec.Tracer.StartFieldChildExecution(ctx)657	return ec.marshalOInt2ᚖint(ctx, field.Selections, res)658}659func (ec *executionContext) _Order_operationId(ctx context.Context, field graphql.CollectedField, obj *models.Order) (ret graphql.Marshaler) {660	ctx = ec.Tracer.StartFieldExecution(ctx, field)661	defer func() {662		if r := recover(); r != nil {663			ec.Error(ctx, ec.Recover(ctx, r))664			ret = graphql.Null665		}666		ec.Tracer.EndFieldExecution(ctx)667	}()668	rctx := &graphql.ResolverContext{669		Object:   "Order",670		Field:    field,671		Args:     nil,672		IsMethod: false,673	}674	ctx = graphql.WithResolverContext(ctx, rctx)675	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)676	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {677		ctx = rctx // use context from middleware stack in children678		return obj.OperationID, nil679	})680	if err != nil {681		ec.Error(ctx, err)682		return graphql.Null683	}684	if resTmp == nil {685		if !ec.HasError(rctx) {686			ec.Errorf(ctx, "must not be null")687		}688		return graphql.Null689	}690	res := resTmp.(string)691	rctx.Result = res692	ctx = ec.Tracer.StartFieldChildExecution(ctx)693	return ec.marshalNID2string(ctx, field.Selections, res)694}695func (ec *executionContext) _Order_shipmentId(ctx context.Context, field graphql.CollectedField, obj *models.Order) (ret graphql.Marshaler) {696	ctx = ec.Tracer.StartFieldExecution(ctx, field)697	defer func() {698		if r := recover(); r != nil {699			ec.Error(ctx, ec.Recover(ctx, r))700			ret = graphql.Null701		}702		ec.Tracer.EndFieldExecution(ctx)703	}()704	rctx := &graphql.ResolverContext{705		Object:   "Order",706		Field:    field,707		Args:     nil,708		IsMethod: false,709	}710	ctx = graphql.WithResolverContext(ctx, rctx)711	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)712	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {713		ctx = rctx // use context from middleware stack in children714		return obj.ShipmentID, nil715	})716	if err != nil {717		ec.Error(ctx, err)718		return graphql.Null719	}720	if resTmp == nil {721		return graphql.Null722	}723	res := resTmp.(*string)724	rctx.Result = res725	ctx = ec.Tracer.StartFieldChildExecution(ctx)726	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)727}728func (ec *executionContext) _Order_lineItems(ctx context.Context, field graphql.CollectedField, obj *models.Order) (ret graphql.Marshaler) {729	ctx = ec.Tracer.StartFieldExecution(ctx, field)730	defer func() {731		if r := recover(); r != nil {732			ec.Error(ctx, ec.Recover(ctx, r))733			ret = graphql.Null734		}735		ec.Tracer.EndFieldExecution(ctx)736	}()737	rctx := &graphql.ResolverContext{738		Object:   "Order",739		Field:    field,740		Args:     nil,741		IsMethod: false,742	}743	ctx = graphql.WithResolverContext(ctx, rctx)744	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)745	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {746		ctx = rctx // use context from middleware stack in children747		return obj.LineItems, nil748	})749	if err != nil {750		ec.Error(ctx, err)751		return graphql.Null752	}753	if resTmp == nil {754		if !ec.HasError(rctx) {755			ec.Errorf(ctx, "must not be null")756		}757		return graphql.Null758	}759	res := resTmp.([]*models.LineItem)760	rctx.Result = res761	ctx = ec.Tracer.StartFieldChildExecution(ctx)762	return ec.marshalNLineItem2ᚕᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐLineItemᚄ(ctx, field.Selections, res)763}764func (ec *executionContext) _Order_carrier(ctx context.Context, field graphql.CollectedField, obj *models.Order) (ret graphql.Marshaler) {765	ctx = ec.Tracer.StartFieldExecution(ctx, field)766	defer func() {767		if r := recover(); r != nil {768			ec.Error(ctx, ec.Recover(ctx, r))769			ret = graphql.Null770		}771		ec.Tracer.EndFieldExecution(ctx)772	}()773	rctx := &graphql.ResolverContext{774		Object:   "Order",775		Field:    field,776		Args:     nil,777		IsMethod: false,778	}779	ctx = graphql.WithResolverContext(ctx, rctx)780	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)781	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {782		ctx = rctx // use context from middleware stack in children783		return obj.Carrier, nil784	})785	if err != nil {786		ec.Error(ctx, err)787		return graphql.Null788	}789	if resTmp == nil {790		return graphql.Null791	}792	res := resTmp.(*string)793	rctx.Result = res794	ctx = ec.Tracer.StartFieldChildExecution(ctx)795	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)796}797func (ec *executionContext) _Order_trackingId(ctx context.Context, field graphql.CollectedField, obj *models.Order) (ret graphql.Marshaler) {798	ctx = ec.Tracer.StartFieldExecution(ctx, field)799	defer func() {800		if r := recover(); r != nil {801			ec.Error(ctx, ec.Recover(ctx, r))802			ret = graphql.Null803		}804		ec.Tracer.EndFieldExecution(ctx)805	}()806	rctx := &graphql.ResolverContext{807		Object:   "Order",808		Field:    field,809		Args:     nil,810		IsMethod: false,811	}812	ctx = graphql.WithResolverContext(ctx, rctx)813	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)814	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {815		ctx = rctx // use context from middleware stack in children816		return obj.TrackingID, nil817	})818	if err != nil {819		ec.Error(ctx, err)820		return graphql.Null821	}822	if resTmp == nil {823		return graphql.Null824	}825	res := resTmp.(*string)826	rctx.Result = res827	ctx = ec.Tracer.StartFieldChildExecution(ctx)828	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)829}830func (ec *executionContext) _Price_currency(ctx context.Context, field graphql.CollectedField, obj *models.Price) (ret graphql.Marshaler) {831	ctx = ec.Tracer.StartFieldExecution(ctx, field)832	defer func() {833		if r := recover(); r != nil {834			ec.Error(ctx, ec.Recover(ctx, r))835			ret = graphql.Null836		}837		ec.Tracer.EndFieldExecution(ctx)838	}()839	rctx := &graphql.ResolverContext{840		Object:   "Price",841		Field:    field,842		Args:     nil,843		IsMethod: false,844	}845	ctx = graphql.WithResolverContext(ctx, rctx)846	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)847	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {848		ctx = rctx // use context from middleware stack in children849		return obj.Currency, nil850	})851	if err != nil {852		ec.Error(ctx, err)853		return graphql.Null854	}855	if resTmp == nil {856		return graphql.Null857	}858	res := resTmp.(*string)859	rctx.Result = res860	ctx = ec.Tracer.StartFieldChildExecution(ctx)861	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)862}863func (ec *executionContext) _Price_value(ctx context.Context, field graphql.CollectedField, obj *models.Price) (ret graphql.Marshaler) {864	ctx = ec.Tracer.StartFieldExecution(ctx, field)865	defer func() {866		if r := recover(); r != nil {867			ec.Error(ctx, ec.Recover(ctx, r))868			ret = graphql.Null869		}870		ec.Tracer.EndFieldExecution(ctx)871	}()872	rctx := &graphql.ResolverContext{873		Object:   "Price",874		Field:    field,875		Args:     nil,876		IsMethod: false,877	}878	ctx = graphql.WithResolverContext(ctx, rctx)879	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)880	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {881		ctx = rctx // use context from middleware stack in children882		return obj.Value, nil883	})884	if err != nil {885		ec.Error(ctx, err)886		return graphql.Null887	}888	if resTmp == nil {889		return graphql.Null890	}891	res := resTmp.(*string)892	rctx.Result = res893	ctx = ec.Tracer.StartFieldChildExecution(ctx)894	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)895}896func (ec *executionContext) _Query_getOrder(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {897	ctx = ec.Tracer.StartFieldExecution(ctx, field)898	defer func() {899		if r := recover(); r != nil {900			ec.Error(ctx, ec.Recover(ctx, r))901			ret = graphql.Null902		}903		ec.Tracer.EndFieldExecution(ctx)904	}()905	rctx := &graphql.ResolverContext{906		Object:   "Query",907		Field:    field,908		Args:     nil,909		IsMethod: true,910	}911	ctx = graphql.WithResolverContext(ctx, rctx)912	rawArgs := field.ArgumentMap(ec.Variables)913	args, err := ec.field_Query_getOrder_args(ctx, rawArgs)914	if err != nil {915		ec.Error(ctx, err)916		return graphql.Null917	}918	rctx.Args = args919	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)920	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {921		ctx = rctx // use context from middleware stack in children922		return ec.resolvers.Query().GetOrder(rctx, args["operationId"].(string))923	})924	if err != nil {925		ec.Error(ctx, err)926		return graphql.Null927	}928	if resTmp == nil {929		return graphql.Null930	}931	res := resTmp.(*models.Order)932	rctx.Result = res933	ctx = ec.Tracer.StartFieldChildExecution(ctx)934	return ec.marshalOOrder2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrder(ctx, field.Selections, res)935}936func (ec *executionContext) _Query_listOrders(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {937	ctx = ec.Tracer.StartFieldExecution(ctx, field)938	defer func() {939		if r := recover(); r != nil {940			ec.Error(ctx, ec.Recover(ctx, r))941			ret = graphql.Null942		}943		ec.Tracer.EndFieldExecution(ctx)944	}()945	rctx := &graphql.ResolverContext{946		Object:   "Query",947		Field:    field,948		Args:     nil,949		IsMethod: true,950	}951	ctx = graphql.WithResolverContext(ctx, rctx)952	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)953	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {954		ctx = rctx // use context from middleware stack in children955		return ec.resolvers.Query().ListOrders(rctx)956	})957	if err != nil {958		ec.Error(ctx, err)959		return graphql.Null960	}961	if resTmp == nil {962		if !ec.HasError(rctx) {963			ec.Errorf(ctx, "must not be null")964		}965		return graphql.Null966	}967	res := resTmp.([]*models.Order)968	rctx.Result = res969	ctx = ec.Tracer.StartFieldChildExecution(ctx)970	return ec.marshalNOrder2ᚕᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrderᚄ(ctx, field.Selections, res)971}972func (ec *executionContext) _Query___type(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {973	ctx = ec.Tracer.StartFieldExecution(ctx, field)974	defer func() {975		if r := recover(); r != nil {976			ec.Error(ctx, ec.Recover(ctx, r))977			ret = graphql.Null978		}979		ec.Tracer.EndFieldExecution(ctx)980	}()981	rctx := &graphql.ResolverContext{982		Object:   "Query",983		Field:    field,984		Args:     nil,985		IsMethod: true,986	}987	ctx = graphql.WithResolverContext(ctx, rctx)988	rawArgs := field.ArgumentMap(ec.Variables)989	args, err := ec.field_Query___type_args(ctx, rawArgs)990	if err != nil {991		ec.Error(ctx, err)992		return graphql.Null993	}994	rctx.Args = args995	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)996	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {997		ctx = rctx // use context from middleware stack in children998		return ec.introspectType(args["name"].(string))999	})1000	if err != nil {1001		ec.Error(ctx, err)1002		return graphql.Null1003	}1004	if resTmp == nil {1005		return graphql.Null1006	}1007	res := resTmp.(*introspection.Type)1008	rctx.Result = res1009	ctx = ec.Tracer.StartFieldChildExecution(ctx)1010	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1011}1012func (ec *executionContext) _Query___schema(ctx context.Context, field graphql.CollectedField) (ret graphql.Marshaler) {1013	ctx = ec.Tracer.StartFieldExecution(ctx, field)1014	defer func() {1015		if r := recover(); r != nil {1016			ec.Error(ctx, ec.Recover(ctx, r))1017			ret = graphql.Null1018		}1019		ec.Tracer.EndFieldExecution(ctx)1020	}()1021	rctx := &graphql.ResolverContext{1022		Object:   "Query",1023		Field:    field,1024		Args:     nil,1025		IsMethod: true,1026	}1027	ctx = graphql.WithResolverContext(ctx, rctx)1028	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1029	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1030		ctx = rctx // use context from middleware stack in children1031		return ec.introspectSchema()1032	})1033	if err != nil {1034		ec.Error(ctx, err)1035		return graphql.Null1036	}1037	if resTmp == nil {1038		return graphql.Null1039	}1040	res := resTmp.(*introspection.Schema)1041	rctx.Result = res1042	ctx = ec.Tracer.StartFieldChildExecution(ctx)1043	return ec.marshalO__Schema2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐSchema(ctx, field.Selections, res)1044}1045func (ec *executionContext) ___Directive_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {1046	ctx = ec.Tracer.StartFieldExecution(ctx, field)1047	defer func() {1048		if r := recover(); r != nil {1049			ec.Error(ctx, ec.Recover(ctx, r))1050			ret = graphql.Null1051		}1052		ec.Tracer.EndFieldExecution(ctx)1053	}()1054	rctx := &graphql.ResolverContext{1055		Object:   "__Directive",1056		Field:    field,1057		Args:     nil,1058		IsMethod: false,1059	}1060	ctx = graphql.WithResolverContext(ctx, rctx)1061	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1062	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1063		ctx = rctx // use context from middleware stack in children1064		return obj.Name, nil1065	})1066	if err != nil {1067		ec.Error(ctx, err)1068		return graphql.Null1069	}1070	if resTmp == nil {1071		if !ec.HasError(rctx) {1072			ec.Errorf(ctx, "must not be null")1073		}1074		return graphql.Null1075	}1076	res := resTmp.(string)1077	rctx.Result = res1078	ctx = ec.Tracer.StartFieldChildExecution(ctx)1079	return ec.marshalNString2string(ctx, field.Selections, res)1080}1081func (ec *executionContext) ___Directive_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {1082	ctx = ec.Tracer.StartFieldExecution(ctx, field)1083	defer func() {1084		if r := recover(); r != nil {1085			ec.Error(ctx, ec.Recover(ctx, r))1086			ret = graphql.Null1087		}1088		ec.Tracer.EndFieldExecution(ctx)1089	}()1090	rctx := &graphql.ResolverContext{1091		Object:   "__Directive",1092		Field:    field,1093		Args:     nil,1094		IsMethod: false,1095	}1096	ctx = graphql.WithResolverContext(ctx, rctx)1097	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1098	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1099		ctx = rctx // use context from middleware stack in children1100		return obj.Description, nil1101	})1102	if err != nil {1103		ec.Error(ctx, err)1104		return graphql.Null1105	}1106	if resTmp == nil {1107		return graphql.Null1108	}1109	res := resTmp.(string)1110	rctx.Result = res1111	ctx = ec.Tracer.StartFieldChildExecution(ctx)1112	return ec.marshalOString2string(ctx, field.Selections, res)1113}1114func (ec *executionContext) ___Directive_locations(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {1115	ctx = ec.Tracer.StartFieldExecution(ctx, field)1116	defer func() {1117		if r := recover(); r != nil {1118			ec.Error(ctx, ec.Recover(ctx, r))1119			ret = graphql.Null1120		}1121		ec.Tracer.EndFieldExecution(ctx)1122	}()1123	rctx := &graphql.ResolverContext{1124		Object:   "__Directive",1125		Field:    field,1126		Args:     nil,1127		IsMethod: false,1128	}1129	ctx = graphql.WithResolverContext(ctx, rctx)1130	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1131	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1132		ctx = rctx // use context from middleware stack in children1133		return obj.Locations, nil1134	})1135	if err != nil {1136		ec.Error(ctx, err)1137		return graphql.Null1138	}1139	if resTmp == nil {1140		if !ec.HasError(rctx) {1141			ec.Errorf(ctx, "must not be null")1142		}1143		return graphql.Null1144	}1145	res := resTmp.([]string)1146	rctx.Result = res1147	ctx = ec.Tracer.StartFieldChildExecution(ctx)1148	return ec.marshalN__DirectiveLocation2ᚕstringᚄ(ctx, field.Selections, res)1149}1150func (ec *executionContext) ___Directive_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Directive) (ret graphql.Marshaler) {1151	ctx = ec.Tracer.StartFieldExecution(ctx, field)1152	defer func() {1153		if r := recover(); r != nil {1154			ec.Error(ctx, ec.Recover(ctx, r))1155			ret = graphql.Null1156		}1157		ec.Tracer.EndFieldExecution(ctx)1158	}()1159	rctx := &graphql.ResolverContext{1160		Object:   "__Directive",1161		Field:    field,1162		Args:     nil,1163		IsMethod: false,1164	}1165	ctx = graphql.WithResolverContext(ctx, rctx)1166	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1167	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1168		ctx = rctx // use context from middleware stack in children1169		return obj.Args, nil1170	})1171	if err != nil {1172		ec.Error(ctx, err)1173		return graphql.Null1174	}1175	if resTmp == nil {1176		if !ec.HasError(rctx) {1177			ec.Errorf(ctx, "must not be null")1178		}1179		return graphql.Null1180	}1181	res := resTmp.([]introspection.InputValue)1182	rctx.Result = res1183	ctx = ec.Tracer.StartFieldChildExecution(ctx)1184	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)1185}1186func (ec *executionContext) ___EnumValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {1187	ctx = ec.Tracer.StartFieldExecution(ctx, field)1188	defer func() {1189		if r := recover(); r != nil {1190			ec.Error(ctx, ec.Recover(ctx, r))1191			ret = graphql.Null1192		}1193		ec.Tracer.EndFieldExecution(ctx)1194	}()1195	rctx := &graphql.ResolverContext{1196		Object:   "__EnumValue",1197		Field:    field,1198		Args:     nil,1199		IsMethod: false,1200	}1201	ctx = graphql.WithResolverContext(ctx, rctx)1202	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1203	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1204		ctx = rctx // use context from middleware stack in children1205		return obj.Name, nil1206	})1207	if err != nil {1208		ec.Error(ctx, err)1209		return graphql.Null1210	}1211	if resTmp == nil {1212		if !ec.HasError(rctx) {1213			ec.Errorf(ctx, "must not be null")1214		}1215		return graphql.Null1216	}1217	res := resTmp.(string)1218	rctx.Result = res1219	ctx = ec.Tracer.StartFieldChildExecution(ctx)1220	return ec.marshalNString2string(ctx, field.Selections, res)1221}1222func (ec *executionContext) ___EnumValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {1223	ctx = ec.Tracer.StartFieldExecution(ctx, field)1224	defer func() {1225		if r := recover(); r != nil {1226			ec.Error(ctx, ec.Recover(ctx, r))1227			ret = graphql.Null1228		}1229		ec.Tracer.EndFieldExecution(ctx)1230	}()1231	rctx := &graphql.ResolverContext{1232		Object:   "__EnumValue",1233		Field:    field,1234		Args:     nil,1235		IsMethod: false,1236	}1237	ctx = graphql.WithResolverContext(ctx, rctx)1238	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1239	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1240		ctx = rctx // use context from middleware stack in children1241		return obj.Description, nil1242	})1243	if err != nil {1244		ec.Error(ctx, err)1245		return graphql.Null1246	}1247	if resTmp == nil {1248		return graphql.Null1249	}1250	res := resTmp.(string)1251	rctx.Result = res1252	ctx = ec.Tracer.StartFieldChildExecution(ctx)1253	return ec.marshalOString2string(ctx, field.Selections, res)1254}1255func (ec *executionContext) ___EnumValue_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {1256	ctx = ec.Tracer.StartFieldExecution(ctx, field)1257	defer func() {1258		if r := recover(); r != nil {1259			ec.Error(ctx, ec.Recover(ctx, r))1260			ret = graphql.Null1261		}1262		ec.Tracer.EndFieldExecution(ctx)1263	}()1264	rctx := &graphql.ResolverContext{1265		Object:   "__EnumValue",1266		Field:    field,1267		Args:     nil,1268		IsMethod: true,1269	}1270	ctx = graphql.WithResolverContext(ctx, rctx)1271	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1272	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1273		ctx = rctx // use context from middleware stack in children1274		return obj.IsDeprecated(), nil1275	})1276	if err != nil {1277		ec.Error(ctx, err)1278		return graphql.Null1279	}1280	if resTmp == nil {1281		if !ec.HasError(rctx) {1282			ec.Errorf(ctx, "must not be null")1283		}1284		return graphql.Null1285	}1286	res := resTmp.(bool)1287	rctx.Result = res1288	ctx = ec.Tracer.StartFieldChildExecution(ctx)1289	return ec.marshalNBoolean2bool(ctx, field.Selections, res)1290}1291func (ec *executionContext) ___EnumValue_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.EnumValue) (ret graphql.Marshaler) {1292	ctx = ec.Tracer.StartFieldExecution(ctx, field)1293	defer func() {1294		if r := recover(); r != nil {1295			ec.Error(ctx, ec.Recover(ctx, r))1296			ret = graphql.Null1297		}1298		ec.Tracer.EndFieldExecution(ctx)1299	}()1300	rctx := &graphql.ResolverContext{1301		Object:   "__EnumValue",1302		Field:    field,1303		Args:     nil,1304		IsMethod: true,1305	}1306	ctx = graphql.WithResolverContext(ctx, rctx)1307	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1308	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1309		ctx = rctx // use context from middleware stack in children1310		return obj.DeprecationReason(), nil1311	})1312	if err != nil {1313		ec.Error(ctx, err)1314		return graphql.Null1315	}1316	if resTmp == nil {1317		return graphql.Null1318	}1319	res := resTmp.(*string)1320	rctx.Result = res1321	ctx = ec.Tracer.StartFieldChildExecution(ctx)1322	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)1323}1324func (ec *executionContext) ___Field_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1325	ctx = ec.Tracer.StartFieldExecution(ctx, field)1326	defer func() {1327		if r := recover(); r != nil {1328			ec.Error(ctx, ec.Recover(ctx, r))1329			ret = graphql.Null1330		}1331		ec.Tracer.EndFieldExecution(ctx)1332	}()1333	rctx := &graphql.ResolverContext{1334		Object:   "__Field",1335		Field:    field,1336		Args:     nil,1337		IsMethod: false,1338	}1339	ctx = graphql.WithResolverContext(ctx, rctx)1340	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1341	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1342		ctx = rctx // use context from middleware stack in children1343		return obj.Name, nil1344	})1345	if err != nil {1346		ec.Error(ctx, err)1347		return graphql.Null1348	}1349	if resTmp == nil {1350		if !ec.HasError(rctx) {1351			ec.Errorf(ctx, "must not be null")1352		}1353		return graphql.Null1354	}1355	res := resTmp.(string)1356	rctx.Result = res1357	ctx = ec.Tracer.StartFieldChildExecution(ctx)1358	return ec.marshalNString2string(ctx, field.Selections, res)1359}1360func (ec *executionContext) ___Field_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1361	ctx = ec.Tracer.StartFieldExecution(ctx, field)1362	defer func() {1363		if r := recover(); r != nil {1364			ec.Error(ctx, ec.Recover(ctx, r))1365			ret = graphql.Null1366		}1367		ec.Tracer.EndFieldExecution(ctx)1368	}()1369	rctx := &graphql.ResolverContext{1370		Object:   "__Field",1371		Field:    field,1372		Args:     nil,1373		IsMethod: false,1374	}1375	ctx = graphql.WithResolverContext(ctx, rctx)1376	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1377	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1378		ctx = rctx // use context from middleware stack in children1379		return obj.Description, nil1380	})1381	if err != nil {1382		ec.Error(ctx, err)1383		return graphql.Null1384	}1385	if resTmp == nil {1386		return graphql.Null1387	}1388	res := resTmp.(string)1389	rctx.Result = res1390	ctx = ec.Tracer.StartFieldChildExecution(ctx)1391	return ec.marshalOString2string(ctx, field.Selections, res)1392}1393func (ec *executionContext) ___Field_args(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1394	ctx = ec.Tracer.StartFieldExecution(ctx, field)1395	defer func() {1396		if r := recover(); r != nil {1397			ec.Error(ctx, ec.Recover(ctx, r))1398			ret = graphql.Null1399		}1400		ec.Tracer.EndFieldExecution(ctx)1401	}()1402	rctx := &graphql.ResolverContext{1403		Object:   "__Field",1404		Field:    field,1405		Args:     nil,1406		IsMethod: false,1407	}1408	ctx = graphql.WithResolverContext(ctx, rctx)1409	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1410	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1411		ctx = rctx // use context from middleware stack in children1412		return obj.Args, nil1413	})1414	if err != nil {1415		ec.Error(ctx, err)1416		return graphql.Null1417	}1418	if resTmp == nil {1419		if !ec.HasError(rctx) {1420			ec.Errorf(ctx, "must not be null")1421		}1422		return graphql.Null1423	}1424	res := resTmp.([]introspection.InputValue)1425	rctx.Result = res1426	ctx = ec.Tracer.StartFieldChildExecution(ctx)1427	return ec.marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)1428}1429func (ec *executionContext) ___Field_type(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1430	ctx = ec.Tracer.StartFieldExecution(ctx, field)1431	defer func() {1432		if r := recover(); r != nil {1433			ec.Error(ctx, ec.Recover(ctx, r))1434			ret = graphql.Null1435		}1436		ec.Tracer.EndFieldExecution(ctx)1437	}()1438	rctx := &graphql.ResolverContext{1439		Object:   "__Field",1440		Field:    field,1441		Args:     nil,1442		IsMethod: false,1443	}1444	ctx = graphql.WithResolverContext(ctx, rctx)1445	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1446	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1447		ctx = rctx // use context from middleware stack in children1448		return obj.Type, nil1449	})1450	if err != nil {1451		ec.Error(ctx, err)1452		return graphql.Null1453	}1454	if resTmp == nil {1455		if !ec.HasError(rctx) {1456			ec.Errorf(ctx, "must not be null")1457		}1458		return graphql.Null1459	}1460	res := resTmp.(*introspection.Type)1461	rctx.Result = res1462	ctx = ec.Tracer.StartFieldChildExecution(ctx)1463	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1464}1465func (ec *executionContext) ___Field_isDeprecated(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1466	ctx = ec.Tracer.StartFieldExecution(ctx, field)1467	defer func() {1468		if r := recover(); r != nil {1469			ec.Error(ctx, ec.Recover(ctx, r))1470			ret = graphql.Null1471		}1472		ec.Tracer.EndFieldExecution(ctx)1473	}()1474	rctx := &graphql.ResolverContext{1475		Object:   "__Field",1476		Field:    field,1477		Args:     nil,1478		IsMethod: true,1479	}1480	ctx = graphql.WithResolverContext(ctx, rctx)1481	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1482	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1483		ctx = rctx // use context from middleware stack in children1484		return obj.IsDeprecated(), nil1485	})1486	if err != nil {1487		ec.Error(ctx, err)1488		return graphql.Null1489	}1490	if resTmp == nil {1491		if !ec.HasError(rctx) {1492			ec.Errorf(ctx, "must not be null")1493		}1494		return graphql.Null1495	}1496	res := resTmp.(bool)1497	rctx.Result = res1498	ctx = ec.Tracer.StartFieldChildExecution(ctx)1499	return ec.marshalNBoolean2bool(ctx, field.Selections, res)1500}1501func (ec *executionContext) ___Field_deprecationReason(ctx context.Context, field graphql.CollectedField, obj *introspection.Field) (ret graphql.Marshaler) {1502	ctx = ec.Tracer.StartFieldExecution(ctx, field)1503	defer func() {1504		if r := recover(); r != nil {1505			ec.Error(ctx, ec.Recover(ctx, r))1506			ret = graphql.Null1507		}1508		ec.Tracer.EndFieldExecution(ctx)1509	}()1510	rctx := &graphql.ResolverContext{1511		Object:   "__Field",1512		Field:    field,1513		Args:     nil,1514		IsMethod: true,1515	}1516	ctx = graphql.WithResolverContext(ctx, rctx)1517	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1518	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1519		ctx = rctx // use context from middleware stack in children1520		return obj.DeprecationReason(), nil1521	})1522	if err != nil {1523		ec.Error(ctx, err)1524		return graphql.Null1525	}1526	if resTmp == nil {1527		return graphql.Null1528	}1529	res := resTmp.(*string)1530	rctx.Result = res1531	ctx = ec.Tracer.StartFieldChildExecution(ctx)1532	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)1533}1534func (ec *executionContext) ___InputValue_name(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {1535	ctx = ec.Tracer.StartFieldExecution(ctx, field)1536	defer func() {1537		if r := recover(); r != nil {1538			ec.Error(ctx, ec.Recover(ctx, r))1539			ret = graphql.Null1540		}1541		ec.Tracer.EndFieldExecution(ctx)1542	}()1543	rctx := &graphql.ResolverContext{1544		Object:   "__InputValue",1545		Field:    field,1546		Args:     nil,1547		IsMethod: false,1548	}1549	ctx = graphql.WithResolverContext(ctx, rctx)1550	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1551	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1552		ctx = rctx // use context from middleware stack in children1553		return obj.Name, nil1554	})1555	if err != nil {1556		ec.Error(ctx, err)1557		return graphql.Null1558	}1559	if resTmp == nil {1560		if !ec.HasError(rctx) {1561			ec.Errorf(ctx, "must not be null")1562		}1563		return graphql.Null1564	}1565	res := resTmp.(string)1566	rctx.Result = res1567	ctx = ec.Tracer.StartFieldChildExecution(ctx)1568	return ec.marshalNString2string(ctx, field.Selections, res)1569}1570func (ec *executionContext) ___InputValue_description(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {1571	ctx = ec.Tracer.StartFieldExecution(ctx, field)1572	defer func() {1573		if r := recover(); r != nil {1574			ec.Error(ctx, ec.Recover(ctx, r))1575			ret = graphql.Null1576		}1577		ec.Tracer.EndFieldExecution(ctx)1578	}()1579	rctx := &graphql.ResolverContext{1580		Object:   "__InputValue",1581		Field:    field,1582		Args:     nil,1583		IsMethod: false,1584	}1585	ctx = graphql.WithResolverContext(ctx, rctx)1586	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1587	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1588		ctx = rctx // use context from middleware stack in children1589		return obj.Description, nil1590	})1591	if err != nil {1592		ec.Error(ctx, err)1593		return graphql.Null1594	}1595	if resTmp == nil {1596		return graphql.Null1597	}1598	res := resTmp.(string)1599	rctx.Result = res1600	ctx = ec.Tracer.StartFieldChildExecution(ctx)1601	return ec.marshalOString2string(ctx, field.Selections, res)1602}1603func (ec *executionContext) ___InputValue_type(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {1604	ctx = ec.Tracer.StartFieldExecution(ctx, field)1605	defer func() {1606		if r := recover(); r != nil {1607			ec.Error(ctx, ec.Recover(ctx, r))1608			ret = graphql.Null1609		}1610		ec.Tracer.EndFieldExecution(ctx)1611	}()1612	rctx := &graphql.ResolverContext{1613		Object:   "__InputValue",1614		Field:    field,1615		Args:     nil,1616		IsMethod: false,1617	}1618	ctx = graphql.WithResolverContext(ctx, rctx)1619	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1620	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1621		ctx = rctx // use context from middleware stack in children1622		return obj.Type, nil1623	})1624	if err != nil {1625		ec.Error(ctx, err)1626		return graphql.Null1627	}1628	if resTmp == nil {1629		if !ec.HasError(rctx) {1630			ec.Errorf(ctx, "must not be null")1631		}1632		return graphql.Null1633	}1634	res := resTmp.(*introspection.Type)1635	rctx.Result = res1636	ctx = ec.Tracer.StartFieldChildExecution(ctx)1637	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1638}1639func (ec *executionContext) ___InputValue_defaultValue(ctx context.Context, field graphql.CollectedField, obj *introspection.InputValue) (ret graphql.Marshaler) {1640	ctx = ec.Tracer.StartFieldExecution(ctx, field)1641	defer func() {1642		if r := recover(); r != nil {1643			ec.Error(ctx, ec.Recover(ctx, r))1644			ret = graphql.Null1645		}1646		ec.Tracer.EndFieldExecution(ctx)1647	}()1648	rctx := &graphql.ResolverContext{1649		Object:   "__InputValue",1650		Field:    field,1651		Args:     nil,1652		IsMethod: false,1653	}1654	ctx = graphql.WithResolverContext(ctx, rctx)1655	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1656	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1657		ctx = rctx // use context from middleware stack in children1658		return obj.DefaultValue, nil1659	})1660	if err != nil {1661		ec.Error(ctx, err)1662		return graphql.Null1663	}1664	if resTmp == nil {1665		return graphql.Null1666	}1667	res := resTmp.(*string)1668	rctx.Result = res1669	ctx = ec.Tracer.StartFieldChildExecution(ctx)1670	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)1671}1672func (ec *executionContext) ___Schema_types(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {1673	ctx = ec.Tracer.StartFieldExecution(ctx, field)1674	defer func() {1675		if r := recover(); r != nil {1676			ec.Error(ctx, ec.Recover(ctx, r))1677			ret = graphql.Null1678		}1679		ec.Tracer.EndFieldExecution(ctx)1680	}()1681	rctx := &graphql.ResolverContext{1682		Object:   "__Schema",1683		Field:    field,1684		Args:     nil,1685		IsMethod: true,1686	}1687	ctx = graphql.WithResolverContext(ctx, rctx)1688	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1689	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1690		ctx = rctx // use context from middleware stack in children1691		return obj.Types(), nil1692	})1693	if err != nil {1694		ec.Error(ctx, err)1695		return graphql.Null1696	}1697	if resTmp == nil {1698		if !ec.HasError(rctx) {1699			ec.Errorf(ctx, "must not be null")1700		}1701		return graphql.Null1702	}1703	res := resTmp.([]introspection.Type)1704	rctx.Result = res1705	ctx = ec.Tracer.StartFieldChildExecution(ctx)1706	return ec.marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)1707}1708func (ec *executionContext) ___Schema_queryType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {1709	ctx = ec.Tracer.StartFieldExecution(ctx, field)1710	defer func() {1711		if r := recover(); r != nil {1712			ec.Error(ctx, ec.Recover(ctx, r))1713			ret = graphql.Null1714		}1715		ec.Tracer.EndFieldExecution(ctx)1716	}()1717	rctx := &graphql.ResolverContext{1718		Object:   "__Schema",1719		Field:    field,1720		Args:     nil,1721		IsMethod: true,1722	}1723	ctx = graphql.WithResolverContext(ctx, rctx)1724	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1725	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1726		ctx = rctx // use context from middleware stack in children1727		return obj.QueryType(), nil1728	})1729	if err != nil {1730		ec.Error(ctx, err)1731		return graphql.Null1732	}1733	if resTmp == nil {1734		if !ec.HasError(rctx) {1735			ec.Errorf(ctx, "must not be null")1736		}1737		return graphql.Null1738	}1739	res := resTmp.(*introspection.Type)1740	rctx.Result = res1741	ctx = ec.Tracer.StartFieldChildExecution(ctx)1742	return ec.marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1743}1744func (ec *executionContext) ___Schema_mutationType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {1745	ctx = ec.Tracer.StartFieldExecution(ctx, field)1746	defer func() {1747		if r := recover(); r != nil {1748			ec.Error(ctx, ec.Recover(ctx, r))1749			ret = graphql.Null1750		}1751		ec.Tracer.EndFieldExecution(ctx)1752	}()1753	rctx := &graphql.ResolverContext{1754		Object:   "__Schema",1755		Field:    field,1756		Args:     nil,1757		IsMethod: true,1758	}1759	ctx = graphql.WithResolverContext(ctx, rctx)1760	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1761	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1762		ctx = rctx // use context from middleware stack in children1763		return obj.MutationType(), nil1764	})1765	if err != nil {1766		ec.Error(ctx, err)1767		return graphql.Null1768	}1769	if resTmp == nil {1770		return graphql.Null1771	}1772	res := resTmp.(*introspection.Type)1773	rctx.Result = res1774	ctx = ec.Tracer.StartFieldChildExecution(ctx)1775	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1776}1777func (ec *executionContext) ___Schema_subscriptionType(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {1778	ctx = ec.Tracer.StartFieldExecution(ctx, field)1779	defer func() {1780		if r := recover(); r != nil {1781			ec.Error(ctx, ec.Recover(ctx, r))1782			ret = graphql.Null1783		}1784		ec.Tracer.EndFieldExecution(ctx)1785	}()1786	rctx := &graphql.ResolverContext{1787		Object:   "__Schema",1788		Field:    field,1789		Args:     nil,1790		IsMethod: true,1791	}1792	ctx = graphql.WithResolverContext(ctx, rctx)1793	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1794	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1795		ctx = rctx // use context from middleware stack in children1796		return obj.SubscriptionType(), nil1797	})1798	if err != nil {1799		ec.Error(ctx, err)1800		return graphql.Null1801	}1802	if resTmp == nil {1803		return graphql.Null1804	}1805	res := resTmp.(*introspection.Type)1806	rctx.Result = res1807	ctx = ec.Tracer.StartFieldChildExecution(ctx)1808	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)1809}1810func (ec *executionContext) ___Schema_directives(ctx context.Context, field graphql.CollectedField, obj *introspection.Schema) (ret graphql.Marshaler) {1811	ctx = ec.Tracer.StartFieldExecution(ctx, field)1812	defer func() {1813		if r := recover(); r != nil {1814			ec.Error(ctx, ec.Recover(ctx, r))1815			ret = graphql.Null1816		}1817		ec.Tracer.EndFieldExecution(ctx)1818	}()1819	rctx := &graphql.ResolverContext{1820		Object:   "__Schema",1821		Field:    field,1822		Args:     nil,1823		IsMethod: true,1824	}1825	ctx = graphql.WithResolverContext(ctx, rctx)1826	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1827	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1828		ctx = rctx // use context from middleware stack in children1829		return obj.Directives(), nil1830	})1831	if err != nil {1832		ec.Error(ctx, err)1833		return graphql.Null1834	}1835	if resTmp == nil {1836		if !ec.HasError(rctx) {1837			ec.Errorf(ctx, "must not be null")1838		}1839		return graphql.Null1840	}1841	res := resTmp.([]introspection.Directive)1842	rctx.Result = res1843	ctx = ec.Tracer.StartFieldChildExecution(ctx)1844	return ec.marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx, field.Selections, res)1845}1846func (ec *executionContext) ___Type_kind(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {1847	ctx = ec.Tracer.StartFieldExecution(ctx, field)1848	defer func() {1849		if r := recover(); r != nil {1850			ec.Error(ctx, ec.Recover(ctx, r))1851			ret = graphql.Null1852		}1853		ec.Tracer.EndFieldExecution(ctx)1854	}()1855	rctx := &graphql.ResolverContext{1856		Object:   "__Type",1857		Field:    field,1858		Args:     nil,1859		IsMethod: true,1860	}1861	ctx = graphql.WithResolverContext(ctx, rctx)1862	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1863	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1864		ctx = rctx // use context from middleware stack in children1865		return obj.Kind(), nil1866	})1867	if err != nil {1868		ec.Error(ctx, err)1869		return graphql.Null1870	}1871	if resTmp == nil {1872		if !ec.HasError(rctx) {1873			ec.Errorf(ctx, "must not be null")1874		}1875		return graphql.Null1876	}1877	res := resTmp.(string)1878	rctx.Result = res1879	ctx = ec.Tracer.StartFieldChildExecution(ctx)1880	return ec.marshalN__TypeKind2string(ctx, field.Selections, res)1881}1882func (ec *executionContext) ___Type_name(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {1883	ctx = ec.Tracer.StartFieldExecution(ctx, field)1884	defer func() {1885		if r := recover(); r != nil {1886			ec.Error(ctx, ec.Recover(ctx, r))1887			ret = graphql.Null1888		}1889		ec.Tracer.EndFieldExecution(ctx)1890	}()1891	rctx := &graphql.ResolverContext{1892		Object:   "__Type",1893		Field:    field,1894		Args:     nil,1895		IsMethod: true,1896	}1897	ctx = graphql.WithResolverContext(ctx, rctx)1898	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1899	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1900		ctx = rctx // use context from middleware stack in children1901		return obj.Name(), nil1902	})1903	if err != nil {1904		ec.Error(ctx, err)1905		return graphql.Null1906	}1907	if resTmp == nil {1908		return graphql.Null1909	}1910	res := resTmp.(*string)1911	rctx.Result = res1912	ctx = ec.Tracer.StartFieldChildExecution(ctx)1913	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)1914}1915func (ec *executionContext) ___Type_description(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {1916	ctx = ec.Tracer.StartFieldExecution(ctx, field)1917	defer func() {1918		if r := recover(); r != nil {1919			ec.Error(ctx, ec.Recover(ctx, r))1920			ret = graphql.Null1921		}1922		ec.Tracer.EndFieldExecution(ctx)1923	}()1924	rctx := &graphql.ResolverContext{1925		Object:   "__Type",1926		Field:    field,1927		Args:     nil,1928		IsMethod: true,1929	}1930	ctx = graphql.WithResolverContext(ctx, rctx)1931	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1932	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1933		ctx = rctx // use context from middleware stack in children1934		return obj.Description(), nil1935	})1936	if err != nil {1937		ec.Error(ctx, err)1938		return graphql.Null1939	}1940	if resTmp == nil {1941		return graphql.Null1942	}1943	res := resTmp.(string)1944	rctx.Result = res1945	ctx = ec.Tracer.StartFieldChildExecution(ctx)1946	return ec.marshalOString2string(ctx, field.Selections, res)1947}1948func (ec *executionContext) ___Type_fields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {1949	ctx = ec.Tracer.StartFieldExecution(ctx, field)1950	defer func() {1951		if r := recover(); r != nil {1952			ec.Error(ctx, ec.Recover(ctx, r))1953			ret = graphql.Null1954		}1955		ec.Tracer.EndFieldExecution(ctx)1956	}()1957	rctx := &graphql.ResolverContext{1958		Object:   "__Type",1959		Field:    field,1960		Args:     nil,1961		IsMethod: true,1962	}1963	ctx = graphql.WithResolverContext(ctx, rctx)1964	rawArgs := field.ArgumentMap(ec.Variables)1965	args, err := ec.field___Type_fields_args(ctx, rawArgs)1966	if err != nil {1967		ec.Error(ctx, err)1968		return graphql.Null1969	}1970	rctx.Args = args1971	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)1972	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {1973		ctx = rctx // use context from middleware stack in children1974		return obj.Fields(args["includeDeprecated"].(bool)), nil1975	})1976	if err != nil {1977		ec.Error(ctx, err)1978		return graphql.Null1979	}1980	if resTmp == nil {1981		return graphql.Null1982	}1983	res := resTmp.([]introspection.Field)1984	rctx.Result = res1985	ctx = ec.Tracer.StartFieldChildExecution(ctx)1986	return ec.marshalO__Field2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐFieldᚄ(ctx, field.Selections, res)1987}1988func (ec *executionContext) ___Type_interfaces(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {1989	ctx = ec.Tracer.StartFieldExecution(ctx, field)1990	defer func() {1991		if r := recover(); r != nil {1992			ec.Error(ctx, ec.Recover(ctx, r))1993			ret = graphql.Null1994		}1995		ec.Tracer.EndFieldExecution(ctx)1996	}()1997	rctx := &graphql.ResolverContext{1998		Object:   "__Type",1999		Field:    field,2000		Args:     nil,2001		IsMethod: true,2002	}2003	ctx = graphql.WithResolverContext(ctx, rctx)2004	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)2005	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {2006		ctx = rctx // use context from middleware stack in children2007		return obj.Interfaces(), nil2008	})2009	if err != nil {2010		ec.Error(ctx, err)2011		return graphql.Null2012	}2013	if resTmp == nil {2014		return graphql.Null2015	}2016	res := resTmp.([]introspection.Type)2017	rctx.Result = res2018	ctx = ec.Tracer.StartFieldChildExecution(ctx)2019	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)2020}2021func (ec *executionContext) ___Type_possibleTypes(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {2022	ctx = ec.Tracer.StartFieldExecution(ctx, field)2023	defer func() {2024		if r := recover(); r != nil {2025			ec.Error(ctx, ec.Recover(ctx, r))2026			ret = graphql.Null2027		}2028		ec.Tracer.EndFieldExecution(ctx)2029	}()2030	rctx := &graphql.ResolverContext{2031		Object:   "__Type",2032		Field:    field,2033		Args:     nil,2034		IsMethod: true,2035	}2036	ctx = graphql.WithResolverContext(ctx, rctx)2037	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)2038	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {2039		ctx = rctx // use context from middleware stack in children2040		return obj.PossibleTypes(), nil2041	})2042	if err != nil {2043		ec.Error(ctx, err)2044		return graphql.Null2045	}2046	if resTmp == nil {2047		return graphql.Null2048	}2049	res := resTmp.([]introspection.Type)2050	rctx.Result = res2051	ctx = ec.Tracer.StartFieldChildExecution(ctx)2052	return ec.marshalO__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx, field.Selections, res)2053}2054func (ec *executionContext) ___Type_enumValues(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {2055	ctx = ec.Tracer.StartFieldExecution(ctx, field)2056	defer func() {2057		if r := recover(); r != nil {2058			ec.Error(ctx, ec.Recover(ctx, r))2059			ret = graphql.Null2060		}2061		ec.Tracer.EndFieldExecution(ctx)2062	}()2063	rctx := &graphql.ResolverContext{2064		Object:   "__Type",2065		Field:    field,2066		Args:     nil,2067		IsMethod: true,2068	}2069	ctx = graphql.WithResolverContext(ctx, rctx)2070	rawArgs := field.ArgumentMap(ec.Variables)2071	args, err := ec.field___Type_enumValues_args(ctx, rawArgs)2072	if err != nil {2073		ec.Error(ctx, err)2074		return graphql.Null2075	}2076	rctx.Args = args2077	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)2078	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {2079		ctx = rctx // use context from middleware stack in children2080		return obj.EnumValues(args["includeDeprecated"].(bool)), nil2081	})2082	if err != nil {2083		ec.Error(ctx, err)2084		return graphql.Null2085	}2086	if resTmp == nil {2087		return graphql.Null2088	}2089	res := resTmp.([]introspection.EnumValue)2090	rctx.Result = res2091	ctx = ec.Tracer.StartFieldChildExecution(ctx)2092	return ec.marshalO__EnumValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValueᚄ(ctx, field.Selections, res)2093}2094func (ec *executionContext) ___Type_inputFields(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {2095	ctx = ec.Tracer.StartFieldExecution(ctx, field)2096	defer func() {2097		if r := recover(); r != nil {2098			ec.Error(ctx, ec.Recover(ctx, r))2099			ret = graphql.Null2100		}2101		ec.Tracer.EndFieldExecution(ctx)2102	}()2103	rctx := &graphql.ResolverContext{2104		Object:   "__Type",2105		Field:    field,2106		Args:     nil,2107		IsMethod: true,2108	}2109	ctx = graphql.WithResolverContext(ctx, rctx)2110	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)2111	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {2112		ctx = rctx // use context from middleware stack in children2113		return obj.InputFields(), nil2114	})2115	if err != nil {2116		ec.Error(ctx, err)2117		return graphql.Null2118	}2119	if resTmp == nil {2120		return graphql.Null2121	}2122	res := resTmp.([]introspection.InputValue)2123	rctx.Result = res2124	ctx = ec.Tracer.StartFieldChildExecution(ctx)2125	return ec.marshalO__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx, field.Selections, res)2126}2127func (ec *executionContext) ___Type_ofType(ctx context.Context, field graphql.CollectedField, obj *introspection.Type) (ret graphql.Marshaler) {2128	ctx = ec.Tracer.StartFieldExecution(ctx, field)2129	defer func() {2130		if r := recover(); r != nil {2131			ec.Error(ctx, ec.Recover(ctx, r))2132			ret = graphql.Null2133		}2134		ec.Tracer.EndFieldExecution(ctx)2135	}()2136	rctx := &graphql.ResolverContext{2137		Object:   "__Type",2138		Field:    field,2139		Args:     nil,2140		IsMethod: true,2141	}2142	ctx = graphql.WithResolverContext(ctx, rctx)2143	ctx = ec.Tracer.StartFieldResolverExecution(ctx, rctx)2144	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {2145		ctx = rctx // use context from middleware stack in children2146		return obj.OfType(), nil2147	})2148	if err != nil {2149		ec.Error(ctx, err)2150		return graphql.Null2151	}2152	if resTmp == nil {2153		return graphql.Null2154	}2155	res := resTmp.(*introspection.Type)2156	rctx.Result = res2157	ctx = ec.Tracer.StartFieldChildExecution(ctx)2158	return ec.marshalO__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, field.Selections, res)2159}2160// endregion **************************** field.gotpl *****************************2161// region    **************************** input.gotpl *****************************2162// endregion **************************** input.gotpl *****************************2163// region    ************************** interface.gotpl ***************************2164// endregion ************************** interface.gotpl ***************************2165// region    **************************** object.gotpl ****************************2166var inventoryImplementors = []string{"Inventory"}2167func (ec *executionContext) _Inventory(ctx context.Context, sel ast.SelectionSet, obj *models.Inventory) graphql.Marshaler {2168	fields := graphql.CollectFields(ec.RequestContext, sel, inventoryImplementors)2169	out := graphql.NewFieldSet(fields)2170	var invalids uint322171	for i, field := range fields {2172		switch field.Name {2173		case "__typename":2174			out.Values[i] = graphql.MarshalString("Inventory")2175		case "salePrice":2176			out.Values[i] = ec._Inventory_salePrice(ctx, field, obj)2177		case "sellOnGoogleQuantity":2178			out.Values[i] = ec._Inventory_sellOnGoogleQuantity(ctx, field, obj)2179		case "availability":2180			out.Values[i] = ec._Inventory_availability(ctx, field, obj)2181		case "kind":2182			out.Values[i] = ec._Inventory_kind(ctx, field, obj)2183		case "price":2184			out.Values[i] = ec._Inventory_price(ctx, field, obj)2185		default:2186			panic("unknown field " + strconv.Quote(field.Name))2187		}2188	}2189	out.Dispatch()2190	if invalids > 0 {2191		return graphql.Null2192	}2193	return out2194}2195var itemImplementors = []string{"Item"}2196func (ec *executionContext) _Item(ctx context.Context, sel ast.SelectionSet, obj *models.Item) graphql.Marshaler {2197	fields := graphql.CollectFields(ec.RequestContext, sel, itemImplementors)2198	out := graphql.NewFieldSet(fields)2199	var invalids uint322200	for i, field := range fields {2201		switch field.Name {2202		case "__typename":2203			out.Values[i] = graphql.MarshalString("Item")2204		case "inventory":2205			out.Values[i] = ec._Item_inventory(ctx, field, obj)2206		case "productId":2207			out.Values[i] = ec._Item_productId(ctx, field, obj)2208		case "storeCode":2209			out.Values[i] = ec._Item_storeCode(ctx, field, obj)2210		default:2211			panic("unknown field " + strconv.Quote(field.Name))2212		}2213	}2214	out.Dispatch()2215	if invalids > 0 {2216		return graphql.Null2217	}2218	return out2219}2220var lineItemImplementors = []string{"LineItem"}2221func (ec *executionContext) _LineItem(ctx context.Context, sel ast.SelectionSet, obj *models.LineItem) graphql.Marshaler {2222	fields := graphql.CollectFields(ec.RequestContext, sel, lineItemImplementors)2223	out := graphql.NewFieldSet(fields)2224	var invalids uint322225	for i, field := range fields {2226		switch field.Name {2227		case "__typename":2228			out.Values[i] = graphql.MarshalString("LineItem")2229		case "item":2230			out.Values[i] = ec._LineItem_item(ctx, field, obj)2231		case "quantity":2232			out.Values[i] = ec._LineItem_quantity(ctx, field, obj)2233		default:2234			panic("unknown field " + strconv.Quote(field.Name))2235		}2236	}2237	out.Dispatch()2238	if invalids > 0 {2239		return graphql.Null2240	}2241	return out2242}2243var orderImplementors = []string{"Order"}2244func (ec *executionContext) _Order(ctx context.Context, sel ast.SelectionSet, obj *models.Order) graphql.Marshaler {2245	fields := graphql.CollectFields(ec.RequestContext, sel, orderImplementors)2246	out := graphql.NewFieldSet(fields)2247	var invalids uint322248	for i, field := range fields {2249		switch field.Name {2250		case "__typename":2251			out.Values[i] = graphql.MarshalString("Order")2252		case "operationId":2253			out.Values[i] = ec._Order_operationId(ctx, field, obj)2254			if out.Values[i] == graphql.Null {2255				invalids++2256			}2257		case "shipmentId":2258			out.Values[i] = ec._Order_shipmentId(ctx, field, obj)2259		case "lineItems":2260			out.Values[i] = ec._Order_lineItems(ctx, field, obj)2261			if out.Values[i] == graphql.Null {2262				invalids++2263			}2264		case "carrier":2265			out.Values[i] = ec._Order_carrier(ctx, field, obj)2266		case "trackingId":2267			out.Values[i] = ec._Order_trackingId(ctx, field, obj)2268		default:2269			panic("unknown field " + strconv.Quote(field.Name))2270		}2271	}2272	out.Dispatch()2273	if invalids > 0 {2274		return graphql.Null2275	}2276	return out2277}2278var priceImplementors = []string{"Price"}2279func (ec *executionContext) _Price(ctx context.Context, sel ast.SelectionSet, obj *models.Price) graphql.Marshaler {2280	fields := graphql.CollectFields(ec.RequestContext, sel, priceImplementors)2281	out := graphql.NewFieldSet(fields)2282	var invalids uint322283	for i, field := range fields {2284		switch field.Name {2285		case "__typename":2286			out.Values[i] = graphql.MarshalString("Price")2287		case "currency":2288			out.Values[i] = ec._Price_currency(ctx, field, obj)2289		case "value":2290			out.Values[i] = ec._Price_value(ctx, field, obj)2291		default:2292			panic("unknown field " + strconv.Quote(field.Name))2293		}2294	}2295	out.Dispatch()2296	if invalids > 0 {2297		return graphql.Null2298	}2299	return out2300}2301var queryImplementors = []string{"Query"}2302func (ec *executionContext) _Query(ctx context.Context, sel ast.SelectionSet) graphql.Marshaler {2303	fields := graphql.CollectFields(ec.RequestContext, sel, queryImplementors)2304	ctx = graphql.WithResolverContext(ctx, &graphql.ResolverContext{2305		Object: "Query",2306	})2307	out := graphql.NewFieldSet(fields)2308	var invalids uint322309	for i, field := range fields {2310		switch field.Name {2311		case "__typename":2312			out.Values[i] = graphql.MarshalString("Query")2313		case "getOrder":2314			field := field2315			out.Concurrently(i, func() (res graphql.Marshaler) {2316				defer func() {2317					if r := recover(); r != nil {2318						ec.Error(ctx, ec.Recover(ctx, r))2319					}2320				}()2321				res = ec._Query_getOrder(ctx, field)2322				return res2323			})2324		case "listOrders":2325			field := field2326			out.Concurrently(i, func() (res graphql.Marshaler) {2327				defer func() {2328					if r := recover(); r != nil {2329						ec.Error(ctx, ec.Recover(ctx, r))2330					}2331				}()2332				res = ec._Query_listOrders(ctx, field)2333				if res == graphql.Null {2334					atomic.AddUint32(&invalids, 1)2335				}2336				return res2337			})2338		case "__type":2339			out.Values[i] = ec._Query___type(ctx, field)2340		case "__schema":2341			out.Values[i] = ec._Query___schema(ctx, field)2342		default:2343			panic("unknown field " + strconv.Quote(field.Name))2344		}2345	}2346	out.Dispatch()2347	if invalids > 0 {2348		return graphql.Null2349	}2350	return out2351}2352var __DirectiveImplementors = []string{"__Directive"}2353func (ec *executionContext) ___Directive(ctx context.Context, sel ast.SelectionSet, obj *introspection.Directive) graphql.Marshaler {2354	fields := graphql.CollectFields(ec.RequestContext, sel, __DirectiveImplementors)2355	out := graphql.NewFieldSet(fields)2356	var invalids uint322357	for i, field := range fields {2358		switch field.Name {2359		case "__typename":2360			out.Values[i] = graphql.MarshalString("__Directive")2361		case "name":2362			out.Values[i] = ec.___Directive_name(ctx, field, obj)2363			if out.Values[i] == graphql.Null {2364				invalids++2365			}2366		case "description":2367			out.Values[i] = ec.___Directive_description(ctx, field, obj)2368		case "locations":2369			out.Values[i] = ec.___Directive_locations(ctx, field, obj)2370			if out.Values[i] == graphql.Null {2371				invalids++2372			}2373		case "args":2374			out.Values[i] = ec.___Directive_args(ctx, field, obj)2375			if out.Values[i] == graphql.Null {2376				invalids++2377			}2378		default:2379			panic("unknown field " + strconv.Quote(field.Name))2380		}2381	}2382	out.Dispatch()2383	if invalids > 0 {2384		return graphql.Null2385	}2386	return out2387}2388var __EnumValueImplementors = []string{"__EnumValue"}2389func (ec *executionContext) ___EnumValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.EnumValue) graphql.Marshaler {2390	fields := graphql.CollectFields(ec.RequestContext, sel, __EnumValueImplementors)2391	out := graphql.NewFieldSet(fields)2392	var invalids uint322393	for i, field := range fields {2394		switch field.Name {2395		case "__typename":2396			out.Values[i] = graphql.MarshalString("__EnumValue")2397		case "name":2398			out.Values[i] = ec.___EnumValue_name(ctx, field, obj)2399			if out.Values[i] == graphql.Null {2400				invalids++2401			}2402		case "description":2403			out.Values[i] = ec.___EnumValue_description(ctx, field, obj)2404		case "isDeprecated":2405			out.Values[i] = ec.___EnumValue_isDeprecated(ctx, field, obj)2406			if out.Values[i] == graphql.Null {2407				invalids++2408			}2409		case "deprecationReason":2410			out.Values[i] = ec.___EnumValue_deprecationReason(ctx, field, obj)2411		default:2412			panic("unknown field " + strconv.Quote(field.Name))2413		}2414	}2415	out.Dispatch()2416	if invalids > 0 {2417		return graphql.Null2418	}2419	return out2420}2421var __FieldImplementors = []string{"__Field"}2422func (ec *executionContext) ___Field(ctx context.Context, sel ast.SelectionSet, obj *introspection.Field) graphql.Marshaler {2423	fields := graphql.CollectFields(ec.RequestContext, sel, __FieldImplementors)2424	out := graphql.NewFieldSet(fields)2425	var invalids uint322426	for i, field := range fields {2427		switch field.Name {2428		case "__typename":2429			out.Values[i] = graphql.MarshalString("__Field")2430		case "name":2431			out.Values[i] = ec.___Field_name(ctx, field, obj)2432			if out.Values[i] == graphql.Null {2433				invalids++2434			}2435		case "description":2436			out.Values[i] = ec.___Field_description(ctx, field, obj)2437		case "args":2438			out.Values[i] = ec.___Field_args(ctx, field, obj)2439			if out.Values[i] == graphql.Null {2440				invalids++2441			}2442		case "type":2443			out.Values[i] = ec.___Field_type(ctx, field, obj)2444			if out.Values[i] == graphql.Null {2445				invalids++2446			}2447		case "isDeprecated":2448			out.Values[i] = ec.___Field_isDeprecated(ctx, field, obj)2449			if out.Values[i] == graphql.Null {2450				invalids++2451			}2452		case "deprecationReason":2453			out.Values[i] = ec.___Field_deprecationReason(ctx, field, obj)2454		default:2455			panic("unknown field " + strconv.Quote(field.Name))2456		}2457	}2458	out.Dispatch()2459	if invalids > 0 {2460		return graphql.Null2461	}2462	return out2463}2464var __InputValueImplementors = []string{"__InputValue"}2465func (ec *executionContext) ___InputValue(ctx context.Context, sel ast.SelectionSet, obj *introspection.InputValue) graphql.Marshaler {2466	fields := graphql.CollectFields(ec.RequestContext, sel, __InputValueImplementors)2467	out := graphql.NewFieldSet(fields)2468	var invalids uint322469	for i, field := range fields {2470		switch field.Name {2471		case "__typename":2472			out.Values[i] = graphql.MarshalString("__InputValue")2473		case "name":2474			out.Values[i] = ec.___InputValue_name(ctx, field, obj)2475			if out.Values[i] == graphql.Null {2476				invalids++2477			}2478		case "description":2479			out.Values[i] = ec.___InputValue_description(ctx, field, obj)2480		case "type":2481			out.Values[i] = ec.___InputValue_type(ctx, field, obj)2482			if out.Values[i] == graphql.Null {2483				invalids++2484			}2485		case "defaultValue":2486			out.Values[i] = ec.___InputValue_defaultValue(ctx, field, obj)2487		default:2488			panic("unknown field " + strconv.Quote(field.Name))2489		}2490	}2491	out.Dispatch()2492	if invalids > 0 {2493		return graphql.Null2494	}2495	return out2496}2497var __SchemaImplementors = []string{"__Schema"}2498func (ec *executionContext) ___Schema(ctx context.Context, sel ast.SelectionSet, obj *introspection.Schema) graphql.Marshaler {2499	fields := graphql.CollectFields(ec.RequestContext, sel, __SchemaImplementors)2500	out := graphql.NewFieldSet(fields)2501	var invalids uint322502	for i, field := range fields {2503		switch field.Name {2504		case "__typename":2505			out.Values[i] = graphql.MarshalString("__Schema")2506		case "types":2507			out.Values[i] = ec.___Schema_types(ctx, field, obj)2508			if out.Values[i] == graphql.Null {2509				invalids++2510			}2511		case "queryType":2512			out.Values[i] = ec.___Schema_queryType(ctx, field, obj)2513			if out.Values[i] == graphql.Null {2514				invalids++2515			}2516		case "mutationType":2517			out.Values[i] = ec.___Schema_mutationType(ctx, field, obj)2518		case "subscriptionType":2519			out.Values[i] = ec.___Schema_subscriptionType(ctx, field, obj)2520		case "directives":2521			out.Values[i] = ec.___Schema_directives(ctx, field, obj)2522			if out.Values[i] == graphql.Null {2523				invalids++2524			}2525		default:2526			panic("unknown field " + strconv.Quote(field.Name))2527		}2528	}2529	out.Dispatch()2530	if invalids > 0 {2531		return graphql.Null2532	}2533	return out2534}2535var __TypeImplementors = []string{"__Type"}2536func (ec *executionContext) ___Type(ctx context.Context, sel ast.SelectionSet, obj *introspection.Type) graphql.Marshaler {2537	fields := graphql.CollectFields(ec.RequestContext, sel, __TypeImplementors)2538	out := graphql.NewFieldSet(fields)2539	var invalids uint322540	for i, field := range fields {2541		switch field.Name {2542		case "__typename":2543			out.Values[i] = graphql.MarshalString("__Type")2544		case "kind":2545			out.Values[i] = ec.___Type_kind(ctx, field, obj)2546			if out.Values[i] == graphql.Null {2547				invalids++2548			}2549		case "name":2550			out.Values[i] = ec.___Type_name(ctx, field, obj)2551		case "description":2552			out.Values[i] = ec.___Type_description(ctx, field, obj)2553		case "fields":2554			out.Values[i] = ec.___Type_fields(ctx, field, obj)2555		case "interfaces":2556			out.Values[i] = ec.___Type_interfaces(ctx, field, obj)2557		case "possibleTypes":2558			out.Values[i] = ec.___Type_possibleTypes(ctx, field, obj)2559		case "enumValues":2560			out.Values[i] = ec.___Type_enumValues(ctx, field, obj)2561		case "inputFields":2562			out.Values[i] = ec.___Type_inputFields(ctx, field, obj)2563		case "ofType":2564			out.Values[i] = ec.___Type_ofType(ctx, field, obj)2565		default:2566			panic("unknown field " + strconv.Quote(field.Name))2567		}2568	}2569	out.Dispatch()2570	if invalids > 0 {2571		return graphql.Null2572	}2573	return out2574}2575// endregion **************************** object.gotpl ****************************2576// region    ***************************** type.gotpl *****************************2577func (ec *executionContext) unmarshalNBoolean2bool(ctx context.Context, v interface{}) (bool, error) {2578	return graphql.UnmarshalBoolean(v)2579}2580func (ec *executionContext) marshalNBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {2581	res := graphql.MarshalBoolean(v)2582	if res == graphql.Null {2583		if !ec.HasError(graphql.GetResolverContext(ctx)) {2584			ec.Errorf(ctx, "must not be null")2585		}2586	}2587	return res2588}2589func (ec *executionContext) unmarshalNID2string(ctx context.Context, v interface{}) (string, error) {2590	return graphql.UnmarshalID(v)2591}2592func (ec *executionContext) marshalNID2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {2593	res := graphql.MarshalID(v)2594	if res == graphql.Null {2595		if !ec.HasError(graphql.GetResolverContext(ctx)) {2596			ec.Errorf(ctx, "must not be null")2597		}2598	}2599	return res2600}2601func (ec *executionContext) marshalNLineItem2githubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐLineItem(ctx context.Context, sel ast.SelectionSet, v models.LineItem) graphql.Marshaler {2602	return ec._LineItem(ctx, sel, &v)2603}2604func (ec *executionContext) marshalNLineItem2ᚕᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐLineItemᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.LineItem) graphql.Marshaler {2605	ret := make(graphql.Array, len(v))2606	var wg sync.WaitGroup2607	isLen1 := len(v) == 12608	if !isLen1 {2609		wg.Add(len(v))2610	}2611	for i := range v {2612		i := i2613		rctx := &graphql.ResolverContext{2614			Index:  &i,2615			Result: &v[i],2616		}2617		ctx := graphql.WithResolverContext(ctx, rctx)2618		f := func(i int) {2619			defer func() {2620				if r := recover(); r != nil {2621					ec.Error(ctx, ec.Recover(ctx, r))2622					ret = nil2623				}2624			}()2625			if !isLen1 {2626				defer wg.Done()2627			}2628			ret[i] = ec.marshalNLineItem2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐLineItem(ctx, sel, v[i])2629		}2630		if isLen1 {2631			f(i)2632		} else {2633			go f(i)2634		}2635	}2636	wg.Wait()2637	return ret2638}2639func (ec *executionContext) marshalNLineItem2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐLineItem(ctx context.Context, sel ast.SelectionSet, v *models.LineItem) graphql.Marshaler {2640	if v == nil {2641		if !ec.HasError(graphql.GetResolverContext(ctx)) {2642			ec.Errorf(ctx, "must not be null")2643		}2644		return graphql.Null2645	}2646	return ec._LineItem(ctx, sel, v)2647}2648func (ec *executionContext) marshalNOrder2githubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrder(ctx context.Context, sel ast.SelectionSet, v models.Order) graphql.Marshaler {2649	return ec._Order(ctx, sel, &v)2650}2651func (ec *executionContext) marshalNOrder2ᚕᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrderᚄ(ctx context.Context, sel ast.SelectionSet, v []*models.Order) graphql.Marshaler {2652	ret := make(graphql.Array, len(v))2653	var wg sync.WaitGroup2654	isLen1 := len(v) == 12655	if !isLen1 {2656		wg.Add(len(v))2657	}2658	for i := range v {2659		i := i2660		rctx := &graphql.ResolverContext{2661			Index:  &i,2662			Result: &v[i],2663		}2664		ctx := graphql.WithResolverContext(ctx, rctx)2665		f := func(i int) {2666			defer func() {2667				if r := recover(); r != nil {2668					ec.Error(ctx, ec.Recover(ctx, r))2669					ret = nil2670				}2671			}()2672			if !isLen1 {2673				defer wg.Done()2674			}2675			ret[i] = ec.marshalNOrder2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrder(ctx, sel, v[i])2676		}2677		if isLen1 {2678			f(i)2679		} else {2680			go f(i)2681		}2682	}2683	wg.Wait()2684	return ret2685}2686func (ec *executionContext) marshalNOrder2ᚖgithubᚗcomᚋsrinandanᚋsampleᚑappsᚋordersᚑgqlᚋmodelsᚐOrder(ctx context.Context, sel ast.SelectionSet, v *models.Order) graphql.Marshaler {2687	if v == nil {2688		if !ec.HasError(graphql.GetResolverContext(ctx)) {2689			ec.Errorf(ctx, "must not be null")2690		}2691		return graphql.Null2692	}2693	return ec._Order(ctx, sel, v)2694}2695func (ec *executionContext) unmarshalNString2string(ctx context.Context, v interface{}) (string, error) {2696	return graphql.UnmarshalString(v)2697}2698func (ec *executionContext) marshalNString2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {2699	res := graphql.MarshalString(v)2700	if res == graphql.Null {2701		if !ec.HasError(graphql.GetResolverContext(ctx)) {2702			ec.Errorf(ctx, "must not be null")2703		}2704	}2705	return res2706}2707func (ec *executionContext) marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx context.Context, sel ast.SelectionSet, v introspection.Directive) graphql.Marshaler {2708	return ec.___Directive(ctx, sel, &v)2709}2710func (ec *executionContext) marshalN__Directive2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirectiveᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Directive) graphql.Marshaler {2711	ret := make(graphql.Array, len(v))2712	var wg sync.WaitGroup2713	isLen1 := len(v) == 12714	if !isLen1 {2715		wg.Add(len(v))2716	}2717	for i := range v {2718		i := i2719		rctx := &graphql.ResolverContext{2720			Index:  &i,2721			Result: &v[i],2722		}2723		ctx := graphql.WithResolverContext(ctx, rctx)2724		f := func(i int) {2725			defer func() {2726				if r := recover(); r != nil {2727					ec.Error(ctx, ec.Recover(ctx, r))2728					ret = nil2729				}2730			}()2731			if !isLen1 {2732				defer wg.Done()2733			}2734			ret[i] = ec.marshalN__Directive2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐDirective(ctx, sel, v[i])2735		}2736		if isLen1 {2737			f(i)2738		} else {2739			go f(i)2740		}2741	}2742	wg.Wait()2743	return ret2744}2745func (ec *executionContext) unmarshalN__DirectiveLocation2string(ctx context.Context, v interface{}) (string, error) {2746	return graphql.UnmarshalString(v)2747}2748func (ec *executionContext) marshalN__DirectiveLocation2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {2749	res := graphql.MarshalString(v)2750	if res == graphql.Null {2751		if !ec.HasError(graphql.GetResolverContext(ctx)) {2752			ec.Errorf(ctx, "must not be null")2753		}2754	}2755	return res2756}2757func (ec *executionContext) unmarshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, v interface{}) ([]string, error) {2758	var vSlice []interface{}2759	if v != nil {2760		if tmp1, ok := v.([]interface{}); ok {2761			vSlice = tmp12762		} else {2763			vSlice = []interface{}{v}2764		}2765	}2766	var err error2767	res := make([]string, len(vSlice))2768	for i := range vSlice {2769		res[i], err = ec.unmarshalN__DirectiveLocation2string(ctx, vSlice[i])2770		if err != nil {2771			return nil, err2772		}2773	}2774	return res, nil2775}2776func (ec *executionContext) marshalN__DirectiveLocation2ᚕstringᚄ(ctx context.Context, sel ast.SelectionSet, v []string) graphql.Marshaler {2777	ret := make(graphql.Array, len(v))2778	var wg sync.WaitGroup2779	isLen1 := len(v) == 12780	if !isLen1 {2781		wg.Add(len(v))2782	}2783	for i := range v {2784		i := i2785		rctx := &graphql.ResolverContext{2786			Index:  &i,2787			Result: &v[i],2788		}2789		ctx := graphql.WithResolverContext(ctx, rctx)2790		f := func(i int) {2791			defer func() {2792				if r := recover(); r != nil {2793					ec.Error(ctx, ec.Recover(ctx, r))2794					ret = nil2795				}2796			}()2797			if !isLen1 {2798				defer wg.Done()2799			}2800			ret[i] = ec.marshalN__DirectiveLocation2string(ctx, sel, v[i])2801		}2802		if isLen1 {2803			f(i)2804		} else {2805			go f(i)2806		}2807	}2808	wg.Wait()2809	return ret2810}2811func (ec *executionContext) marshalN__EnumValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐEnumValue(ctx context.Context, sel ast.SelectionSet, v introspection.EnumValue) graphql.Marshaler {2812	return ec.___EnumValue(ctx, sel, &v)2813}2814func (ec *executionContext) marshalN__Field2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐField(ctx context.Context, sel ast.SelectionSet, v introspection.Field) graphql.Marshaler {2815	return ec.___Field(ctx, sel, &v)2816}2817func (ec *executionContext) marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx context.Context, sel ast.SelectionSet, v introspection.InputValue) graphql.Marshaler {2818	return ec.___InputValue(ctx, sel, &v)2819}2820func (ec *executionContext) marshalN__InputValue2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValueᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.InputValue) graphql.Marshaler {2821	ret := make(graphql.Array, len(v))2822	var wg sync.WaitGroup2823	isLen1 := len(v) == 12824	if !isLen1 {2825		wg.Add(len(v))2826	}2827	for i := range v {2828		i := i2829		rctx := &graphql.ResolverContext{2830			Index:  &i,2831			Result: &v[i],2832		}2833		ctx := graphql.WithResolverContext(ctx, rctx)2834		f := func(i int) {2835			defer func() {2836				if r := recover(); r != nil {2837					ec.Error(ctx, ec.Recover(ctx, r))2838					ret = nil2839				}2840			}()2841			if !isLen1 {2842				defer wg.Done()2843			}2844			ret[i] = ec.marshalN__InputValue2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐInputValue(ctx, sel, v[i])2845		}2846		if isLen1 {2847			f(i)2848		} else {2849			go f(i)2850		}2851	}2852	wg.Wait()2853	return ret2854}2855func (ec *executionContext) marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v introspection.Type) graphql.Marshaler {2856	return ec.___Type(ctx, sel, &v)2857}2858func (ec *executionContext) marshalN__Type2ᚕgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐTypeᚄ(ctx context.Context, sel ast.SelectionSet, v []introspection.Type) graphql.Marshaler {2859	ret := make(graphql.Array, len(v))2860	var wg sync.WaitGroup2861	isLen1 := len(v) == 12862	if !isLen1 {2863		wg.Add(len(v))2864	}2865	for i := range v {2866		i := i2867		rctx := &graphql.ResolverContext{2868			Index:  &i,2869			Result: &v[i],2870		}2871		ctx := graphql.WithResolverContext(ctx, rctx)2872		f := func(i int) {2873			defer func() {2874				if r := recover(); r != nil {2875					ec.Error(ctx, ec.Recover(ctx, r))2876					ret = nil2877				}2878			}()2879			if !isLen1 {2880				defer wg.Done()2881			}2882			ret[i] = ec.marshalN__Type2githubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx, sel, v[i])2883		}2884		if isLen1 {2885			f(i)2886		} else {2887			go f(i)2888		}2889	}2890	wg.Wait()2891	return ret2892}2893func (ec *executionContext) marshalN__Type2ᚖgithubᚗcomᚋ99designsᚋgqlgenᚋgraphqlᚋintrospectionᚐType(ctx context.Context, sel ast.SelectionSet, v *introspection.Type) graphql.Marshaler {2894	if v == nil {2895		if !ec.HasError(graphql.GetResolverContext(ctx)) {2896			ec.Errorf(ctx, "must not be null")2897		}2898		return graphql.Null2899	}2900	return ec.___Type(ctx, sel, v)2901}2902func (ec *executionContext) unmarshalN__TypeKind2string(ctx context.Context, v interface{}) (string, error) {2903	return graphql.UnmarshalString(v)2904}2905func (ec *executionContext) marshalN__TypeKind2string(ctx context.Context, sel ast.SelectionSet, v string) graphql.Marshaler {2906	res := graphql.MarshalString(v)2907	if res == graphql.Null {2908		if !ec.HasError(graphql.GetResolverContext(ctx)) {2909			ec.Errorf(ctx, "must not be null")2910		}2911	}2912	return res2913}2914func (ec *executionContext) unmarshalOBoolean2bool(ctx context.Context, v interface{}) (bool, error) {2915	return graphql.UnmarshalBoolean(v)2916}2917func (ec *executionContext) marshalOBoolean2bool(ctx context.Context, sel ast.SelectionSet, v bool) graphql.Marshaler {2918	return graphql.MarshalBoolean(v)2919}2920func (ec *executionContext) unmarshalOBoolean2ᚖbool(ctx context.Context, v interface{}) (*bool, error) {2921	if v == nil {2922		return nil, nil2923	}2924	res, err := ec.unmarshalOBoolean2bool(ctx, v)2925	return &res, err2926}2927func (ec *executionContext) marshalOBoolean2ᚖbool(ctx context.Context, sel ast.SelectionSet, v *bool) graphql.Marshaler {2928	if v == nil {2929		return graphql.Null2930	}2931	return ec.marshalOBoolean2bool(ctx, sel, *v)2932}2933func (ec *executionContext) unmarshalOInt2int(ctx context.Context, v interface{}) (int, error) {2934	return graphql.UnmarshalInt(v)2935}2936func (ec *executionContext) marshalOInt2int(ctx context.Context, sel ast.SelectionSet, v int) graphql.Marshaler {2937	return graphql.MarshalInt(v)2938}2939func (ec *executionContext) unmarshalOInt2ᚖint(ctx context.Context, v interface{}) (*int, error) {2940	if v == nil {2941		return nil, nil2942	}2943	res, err := ec.unmarshalOInt2int(ctx, v)2944	return &res, err2945}...