// Code generated by github.com/99designs/gqlgen, DO NOT EDIT.

package graph

import (
	"context"
	"errors"
	"fmt"
	"strconv"
	"sync/atomic"

	"github.com/99designs/gqlgen/graphql"
	"github.com/git-bug/git-bug/api/graphql/models"
	"github.com/git-bug/git-bug/entities/bug"
	"github.com/vektah/gqlparser/v2/ast"
)

// region    ************************** generated!.gotpl **************************

// endregion ************************** generated!.gotpl **************************

// region    ***************************** args.gotpl *****************************

// endregion ***************************** args.gotpl *****************************

// region    ************************** directives.gotpl **************************

// endregion ************************** directives.gotpl **************************

// region    **************************** field.gotpl *****************************

func (ec *executionContext) _BugAddCommentAndClosePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndClosePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndClosePayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_commentOperation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CommentOperation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.AddCommentOperation)
	fc.Result = res
	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
			case "message":
				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
			case "files":
				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndClosePayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndClosePayload_statusOperation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StatusOperation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.SetStatusOperation)
	fc.Result = res
	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndClosePayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
			case "status":
				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndReopenPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndReopenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndReopenPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndReopenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndReopenPayload_commentOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_commentOperation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.CommentOperation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.AddCommentOperation)
	fc.Result = res
	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_commentOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndReopenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
			case "message":
				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
			case "files":
				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentAndReopenPayload_statusOperation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentAndReopenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentAndReopenPayload_statusOperation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.StatusOperation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.SetStatusOperation)
	fc.Result = res
	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentAndReopenPayload_statusOperation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentAndReopenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
			case "status":
				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentPayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentPayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugAddCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugAddCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugAddCommentPayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.AddCommentOperation)
	fc.Result = res
	return ec.marshalNBugAddCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐAddCommentOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugAddCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugAddCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugAddCommentOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugAddCommentOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugAddCommentOperation_date(ctx, field)
			case "message":
				return ec.fieldContext_BugAddCommentOperation_message(ctx, field)
			case "files":
				return ec.fieldContext_BugAddCommentOperation_files(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugAddCommentOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugChangeLabelPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugChangeLabelPayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugChangeLabelPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugChangeLabelPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugChangeLabelPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugChangeLabelPayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugChangeLabelPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugChangeLabelPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugChangeLabelPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugChangeLabelPayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.LabelChangeOperation)
	fc.Result = res
	return ec.marshalNBugLabelChangeOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugChangeLabelPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugChangeLabelPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugLabelChangeOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugLabelChangeOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugLabelChangeOperation_date(ctx, field)
			case "added":
				return ec.fieldContext_BugLabelChangeOperation_added(ctx, field)
			case "removed":
				return ec.fieldContext_BugLabelChangeOperation_removed(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugLabelChangeOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugChangeLabelPayload_results(ctx context.Context, field graphql.CollectedField, obj *models.BugChangeLabelPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugChangeLabelPayload_results(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Results, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.([]*bug.LabelChangeResult)
	fc.Result = res
	return ec.marshalNLabelChangeResult2ᚕᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐLabelChangeResult(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugChangeLabelPayload_results(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugChangeLabelPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "label":
				return ec.fieldContext_LabelChangeResult_label(ctx, field)
			case "status":
				return ec.fieldContext_LabelChangeResult_status(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type LabelChangeResult", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugCreatePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugCreatePayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugCreatePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugCreatePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugCreatePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugCreatePayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugCreatePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugCreatePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugCreatePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugCreatePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugCreatePayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.CreateOperation)
	fc.Result = res
	return ec.marshalNBugCreateOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐCreateOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugCreatePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugCreatePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugCreateOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugCreateOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugCreateOperation_date(ctx, field)
			case "title":
				return ec.fieldContext_BugCreateOperation_title(ctx, field)
			case "message":
				return ec.fieldContext_BugCreateOperation_message(ctx, field)
			case "files":
				return ec.fieldContext_BugCreateOperation_files(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugCreateOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugEditCommentPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugEditCommentPayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugEditCommentPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugEditCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugEditCommentPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugEditCommentPayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugEditCommentPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugEditCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugEditCommentPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugEditCommentPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugEditCommentPayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.EditCommentOperation)
	fc.Result = res
	return ec.marshalNBugEditCommentOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐEditCommentOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugEditCommentPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugEditCommentPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugEditCommentOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugEditCommentOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugEditCommentOperation_date(ctx, field)
			case "target":
				return ec.fieldContext_BugEditCommentOperation_target(ctx, field)
			case "message":
				return ec.fieldContext_BugEditCommentOperation_message(ctx, field)
			case "files":
				return ec.fieldContext_BugEditCommentOperation_files(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugEditCommentOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugSetTitlePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugSetTitlePayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugSetTitlePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugSetTitlePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugSetTitlePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugSetTitlePayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugSetTitlePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugSetTitlePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugSetTitlePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugSetTitlePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugSetTitlePayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.SetTitleOperation)
	fc.Result = res
	return ec.marshalNBugSetTitleOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetTitleOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugSetTitlePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugSetTitlePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugSetTitleOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugSetTitleOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugSetTitleOperation_date(ctx, field)
			case "title":
				return ec.fieldContext_BugSetTitleOperation_title(ctx, field)
			case "was":
				return ec.fieldContext_BugSetTitleOperation_was(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugSetTitleOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusClosePayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusClosePayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusClosePayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusClosePayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusClosePayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusClosePayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusClosePayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusClosePayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusClosePayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.SetStatusOperation)
	fc.Result = res
	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusClosePayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusClosePayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
			case "status":
				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusOpenPayload_clientMutationId(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusOpenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusOpenPayload_clientMutationId(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.ClientMutationID, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		return graphql.Null
	}
	res := resTmp.(*string)
	fc.Result = res
	return ec.marshalOString2ᚖstring(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusOpenPayload_clientMutationId(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusOpenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			return nil, errors.New("field of type String does not have child fields")
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusOpenPayload_bug(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusOpenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusOpenPayload_bug(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Bug, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(models.BugWrapper)
	fc.Result = res
	return ec.marshalNBug2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugWrapper(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusOpenPayload_bug(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusOpenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_Bug_id(ctx, field)
			case "humanId":
				return ec.fieldContext_Bug_humanId(ctx, field)
			case "status":
				return ec.fieldContext_Bug_status(ctx, field)
			case "title":
				return ec.fieldContext_Bug_title(ctx, field)
			case "labels":
				return ec.fieldContext_Bug_labels(ctx, field)
			case "author":
				return ec.fieldContext_Bug_author(ctx, field)
			case "createdAt":
				return ec.fieldContext_Bug_createdAt(ctx, field)
			case "lastEdit":
				return ec.fieldContext_Bug_lastEdit(ctx, field)
			case "actors":
				return ec.fieldContext_Bug_actors(ctx, field)
			case "participants":
				return ec.fieldContext_Bug_participants(ctx, field)
			case "comments":
				return ec.fieldContext_Bug_comments(ctx, field)
			case "timeline":
				return ec.fieldContext_Bug_timeline(ctx, field)
			case "operations":
				return ec.fieldContext_Bug_operations(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type Bug", field.Name)
		},
	}
	return fc, nil
}

func (ec *executionContext) _BugStatusOpenPayload_operation(ctx context.Context, field graphql.CollectedField, obj *models.BugStatusOpenPayload) (ret graphql.Marshaler) {
	fc, err := ec.fieldContext_BugStatusOpenPayload_operation(ctx, field)
	if err != nil {
		return graphql.Null
	}
	ctx = graphql.WithFieldContext(ctx, fc)
	defer func() {
		if r := recover(); r != nil {
			ec.Error(ctx, ec.Recover(ctx, r))
			ret = graphql.Null
		}
	}()
	resTmp, err := ec.ResolverMiddleware(ctx, func(rctx context.Context) (interface{}, error) {
		ctx = rctx // use context from middleware stack in children
		return obj.Operation, nil
	})
	if err != nil {
		ec.Error(ctx, err)
		return graphql.Null
	}
	if resTmp == nil {
		if !graphql.HasFieldError(ctx, fc) {
			ec.Errorf(ctx, "must not be null")
		}
		return graphql.Null
	}
	res := resTmp.(*bug.SetStatusOperation)
	fc.Result = res
	return ec.marshalNBugSetStatusOperation2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋentitiesᚋbugᚐSetStatusOperation(ctx, field.Selections, res)
}

func (ec *executionContext) fieldContext_BugStatusOpenPayload_operation(_ context.Context, field graphql.CollectedField) (fc *graphql.FieldContext, err error) {
	fc = &graphql.FieldContext{
		Object:     "BugStatusOpenPayload",
		Field:      field,
		IsMethod:   false,
		IsResolver: false,
		Child: func(ctx context.Context, field graphql.CollectedField) (*graphql.FieldContext, error) {
			switch field.Name {
			case "id":
				return ec.fieldContext_BugSetStatusOperation_id(ctx, field)
			case "author":
				return ec.fieldContext_BugSetStatusOperation_author(ctx, field)
			case "date":
				return ec.fieldContext_BugSetStatusOperation_date(ctx, field)
			case "status":
				return ec.fieldContext_BugSetStatusOperation_status(ctx, field)
			}
			return nil, fmt.Errorf("no field named %q was found under type BugSetStatusOperation", field.Name)
		},
	}
	return fc, nil
}

// endregion **************************** field.gotpl *****************************

// region    **************************** input.gotpl *****************************

func (ec *executionContext) unmarshalInputBugAddCommentAndCloseInput(ctx context.Context, obj interface{}) (models.BugAddCommentAndCloseInput, error) {
	var it models.BugAddCommentAndCloseInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		case "message":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Message = data
		case "files":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
			data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Files = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugAddCommentAndReopenInput(ctx context.Context, obj interface{}) (models.BugAddCommentAndReopenInput, error) {
	var it models.BugAddCommentAndReopenInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		case "message":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Message = data
		case "files":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
			data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Files = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugAddCommentInput(ctx context.Context, obj interface{}) (models.BugAddCommentInput, error) {
	var it models.BugAddCommentInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "message", "files"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		case "message":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Message = data
		case "files":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
			data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Files = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugChangeLabelInput(ctx context.Context, obj interface{}) (models.BugChangeLabelInput, error) {
	var it models.BugChangeLabelInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "added", "Removed"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		case "added":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("added"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Added = data
		case "Removed":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("Removed"))
			data, err := ec.unmarshalOString2ᚕstringᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Removed = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugCreateInput(ctx context.Context, obj interface{}) (models.BugCreateInput, error) {
	var it models.BugCreateInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "title", "message", "files"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "title":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Title = data
		case "message":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Message = data
		case "files":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
			data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Files = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugEditCommentInput(ctx context.Context, obj interface{}) (models.BugEditCommentInput, error) {
	var it models.BugEditCommentInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "targetPrefix", "message", "files"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "targetPrefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("targetPrefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.TargetPrefix = data
		case "message":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("message"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Message = data
		case "files":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("files"))
			data, err := ec.unmarshalOHash2ᚕgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋrepositoryᚐHashᚄ(ctx, v)
			if err != nil {
				return it, err
			}
			it.Files = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugSetTitleInput(ctx context.Context, obj interface{}) (models.BugSetTitleInput, error) {
	var it models.BugSetTitleInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix", "title"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		case "title":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("title"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Title = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugStatusCloseInput(ctx context.Context, obj interface{}) (models.BugStatusCloseInput, error) {
	var it models.BugStatusCloseInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		}
	}

	return it, nil
}

func (ec *executionContext) unmarshalInputBugStatusOpenInput(ctx context.Context, obj interface{}) (models.BugStatusOpenInput, error) {
	var it models.BugStatusOpenInput
	asMap := map[string]interface{}{}
	for k, v := range obj.(map[string]interface{}) {
		asMap[k] = v
	}

	fieldsInOrder := [...]string{"clientMutationId", "repoRef", "prefix"}
	for _, k := range fieldsInOrder {
		v, ok := asMap[k]
		if !ok {
			continue
		}
		switch k {
		case "clientMutationId":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("clientMutationId"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.ClientMutationID = data
		case "repoRef":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("repoRef"))
			data, err := ec.unmarshalOString2ᚖstring(ctx, v)
			if err != nil {
				return it, err
			}
			it.RepoRef = data
		case "prefix":
			ctx := graphql.WithPathContext(ctx, graphql.NewPathWithField("prefix"))
			data, err := ec.unmarshalNString2string(ctx, v)
			if err != nil {
				return it, err
			}
			it.Prefix = data
		}
	}

	return it, nil
}

// endregion **************************** input.gotpl *****************************

// region    ************************** interface.gotpl ***************************

// endregion ************************** interface.gotpl ***************************

// region    **************************** object.gotpl ****************************

var bugAddCommentAndClosePayloadImplementors = []string{"BugAddCommentAndClosePayload"}

func (ec *executionContext) _BugAddCommentAndClosePayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugAddCommentAndClosePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugAddCommentAndClosePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugAddCommentAndClosePayload")
		case "clientMutationId":
			out.Values[i] = ec._BugAddCommentAndClosePayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugAddCommentAndClosePayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "commentOperation":
			out.Values[i] = ec._BugAddCommentAndClosePayload_commentOperation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "statusOperation":
			out.Values[i] = ec._BugAddCommentAndClosePayload_statusOperation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugAddCommentAndReopenPayloadImplementors = []string{"BugAddCommentAndReopenPayload"}

func (ec *executionContext) _BugAddCommentAndReopenPayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugAddCommentAndReopenPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugAddCommentAndReopenPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugAddCommentAndReopenPayload")
		case "clientMutationId":
			out.Values[i] = ec._BugAddCommentAndReopenPayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugAddCommentAndReopenPayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "commentOperation":
			out.Values[i] = ec._BugAddCommentAndReopenPayload_commentOperation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "statusOperation":
			out.Values[i] = ec._BugAddCommentAndReopenPayload_statusOperation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugAddCommentPayloadImplementors = []string{"BugAddCommentPayload"}

func (ec *executionContext) _BugAddCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugAddCommentPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugAddCommentPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugAddCommentPayload")
		case "clientMutationId":
			out.Values[i] = ec._BugAddCommentPayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugAddCommentPayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugAddCommentPayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugChangeLabelPayloadImplementors = []string{"BugChangeLabelPayload"}

func (ec *executionContext) _BugChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugChangeLabelPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugChangeLabelPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugChangeLabelPayload")
		case "clientMutationId":
			out.Values[i] = ec._BugChangeLabelPayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugChangeLabelPayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugChangeLabelPayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "results":
			out.Values[i] = ec._BugChangeLabelPayload_results(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugCreatePayloadImplementors = []string{"BugCreatePayload"}

func (ec *executionContext) _BugCreatePayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugCreatePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugCreatePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugCreatePayload")
		case "clientMutationId":
			out.Values[i] = ec._BugCreatePayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugCreatePayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugCreatePayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugEditCommentPayloadImplementors = []string{"BugEditCommentPayload"}

func (ec *executionContext) _BugEditCommentPayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugEditCommentPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugEditCommentPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugEditCommentPayload")
		case "clientMutationId":
			out.Values[i] = ec._BugEditCommentPayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugEditCommentPayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugEditCommentPayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugSetTitlePayloadImplementors = []string{"BugSetTitlePayload"}

func (ec *executionContext) _BugSetTitlePayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugSetTitlePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugSetTitlePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugSetTitlePayload")
		case "clientMutationId":
			out.Values[i] = ec._BugSetTitlePayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugSetTitlePayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugSetTitlePayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugStatusClosePayloadImplementors = []string{"BugStatusClosePayload"}

func (ec *executionContext) _BugStatusClosePayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugStatusClosePayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugStatusClosePayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugStatusClosePayload")
		case "clientMutationId":
			out.Values[i] = ec._BugStatusClosePayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugStatusClosePayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugStatusClosePayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

var bugStatusOpenPayloadImplementors = []string{"BugStatusOpenPayload"}

func (ec *executionContext) _BugStatusOpenPayload(ctx context.Context, sel ast.SelectionSet, obj *models.BugStatusOpenPayload) graphql.Marshaler {
	fields := graphql.CollectFields(ec.OperationContext, sel, bugStatusOpenPayloadImplementors)

	out := graphql.NewFieldSet(fields)
	deferred := make(map[string]*graphql.FieldSet)
	for i, field := range fields {
		switch field.Name {
		case "__typename":
			out.Values[i] = graphql.MarshalString("BugStatusOpenPayload")
		case "clientMutationId":
			out.Values[i] = ec._BugStatusOpenPayload_clientMutationId(ctx, field, obj)
		case "bug":
			out.Values[i] = ec._BugStatusOpenPayload_bug(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		case "operation":
			out.Values[i] = ec._BugStatusOpenPayload_operation(ctx, field, obj)
			if out.Values[i] == graphql.Null {
				out.Invalids++
			}
		default:
			panic("unknown field " + strconv.Quote(field.Name))
		}
	}
	out.Dispatch(ctx)
	if out.Invalids > 0 {
		return graphql.Null
	}

	atomic.AddInt32(&ec.deferred, int32(len(deferred)))

	for label, dfs := range deferred {
		ec.processDeferredGroup(graphql.DeferredGroup{
			Label:    label,
			Path:     graphql.GetPath(ctx),
			FieldSet: dfs,
			Context:  ctx,
		})
	}

	return out
}

// endregion **************************** object.gotpl ****************************

// region    ***************************** type.gotpl *****************************

func (ec *executionContext) unmarshalNBugAddCommentAndCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndCloseInput(ctx context.Context, v interface{}) (models.BugAddCommentAndCloseInput, error) {
	res, err := ec.unmarshalInputBugAddCommentAndCloseInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugAddCommentAndClosePayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndClosePayload(ctx context.Context, sel ast.SelectionSet, v models.BugAddCommentAndClosePayload) graphql.Marshaler {
	return ec._BugAddCommentAndClosePayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugAddCommentAndClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndClosePayload(ctx context.Context, sel ast.SelectionSet, v *models.BugAddCommentAndClosePayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugAddCommentAndClosePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugAddCommentAndReopenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenInput(ctx context.Context, v interface{}) (models.BugAddCommentAndReopenInput, error) {
	res, err := ec.unmarshalInputBugAddCommentAndReopenInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugAddCommentAndReopenPayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenPayload(ctx context.Context, sel ast.SelectionSet, v models.BugAddCommentAndReopenPayload) graphql.Marshaler {
	return ec._BugAddCommentAndReopenPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugAddCommentAndReopenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentAndReopenPayload(ctx context.Context, sel ast.SelectionSet, v *models.BugAddCommentAndReopenPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugAddCommentAndReopenPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugAddCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentInput(ctx context.Context, v interface{}) (models.BugAddCommentInput, error) {
	res, err := ec.unmarshalInputBugAddCommentInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugAddCommentPayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.BugAddCommentPayload) graphql.Marshaler {
	return ec._BugAddCommentPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugAddCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugAddCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.BugAddCommentPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugAddCommentPayload(ctx, sel, v)
}

func (ec *executionContext) marshalNBugChangeLabelPayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v models.BugChangeLabelPayload) graphql.Marshaler {
	return ec._BugChangeLabelPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugChangeLabelPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelPayload(ctx context.Context, sel ast.SelectionSet, v *models.BugChangeLabelPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugChangeLabelPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugCreateInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreateInput(ctx context.Context, v interface{}) (models.BugCreateInput, error) {
	res, err := ec.unmarshalInputBugCreateInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugCreatePayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreatePayload(ctx context.Context, sel ast.SelectionSet, v models.BugCreatePayload) graphql.Marshaler {
	return ec._BugCreatePayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugCreatePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugCreatePayload(ctx context.Context, sel ast.SelectionSet, v *models.BugCreatePayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugCreatePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugEditCommentInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentInput(ctx context.Context, v interface{}) (models.BugEditCommentInput, error) {
	res, err := ec.unmarshalInputBugEditCommentInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugEditCommentPayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v models.BugEditCommentPayload) graphql.Marshaler {
	return ec._BugEditCommentPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugEditCommentPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugEditCommentPayload(ctx context.Context, sel ast.SelectionSet, v *models.BugEditCommentPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugEditCommentPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugSetTitleInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitleInput(ctx context.Context, v interface{}) (models.BugSetTitleInput, error) {
	res, err := ec.unmarshalInputBugSetTitleInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugSetTitlePayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v models.BugSetTitlePayload) graphql.Marshaler {
	return ec._BugSetTitlePayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugSetTitlePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugSetTitlePayload(ctx context.Context, sel ast.SelectionSet, v *models.BugSetTitlePayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugSetTitlePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugStatusCloseInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusCloseInput(ctx context.Context, v interface{}) (models.BugStatusCloseInput, error) {
	res, err := ec.unmarshalInputBugStatusCloseInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugStatusClosePayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusClosePayload(ctx context.Context, sel ast.SelectionSet, v models.BugStatusClosePayload) graphql.Marshaler {
	return ec._BugStatusClosePayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugStatusClosePayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusClosePayload(ctx context.Context, sel ast.SelectionSet, v *models.BugStatusClosePayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugStatusClosePayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalNBugStatusOpenInput2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenInput(ctx context.Context, v interface{}) (models.BugStatusOpenInput, error) {
	res, err := ec.unmarshalInputBugStatusOpenInput(ctx, v)
	return res, graphql.ErrorOnPath(ctx, err)
}

func (ec *executionContext) marshalNBugStatusOpenPayload2githubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenPayload(ctx context.Context, sel ast.SelectionSet, v models.BugStatusOpenPayload) graphql.Marshaler {
	return ec._BugStatusOpenPayload(ctx, sel, &v)
}

func (ec *executionContext) marshalNBugStatusOpenPayload2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugStatusOpenPayload(ctx context.Context, sel ast.SelectionSet, v *models.BugStatusOpenPayload) graphql.Marshaler {
	if v == nil {
		if !graphql.HasFieldError(ctx, graphql.GetFieldContext(ctx)) {
			ec.Errorf(ctx, "the requested element is null which the schema does not allow")
		}
		return graphql.Null
	}
	return ec._BugStatusOpenPayload(ctx, sel, v)
}

func (ec *executionContext) unmarshalOBugChangeLabelInput2ᚖgithubᚗcomᚋgitᚑbugᚋgitᚑbugᚋapiᚋgraphqlᚋmodelsᚐBugChangeLabelInput(ctx context.Context, v interface{}) (*models.BugChangeLabelInput, error) {
	if v == nil {
		return nil, nil
	}
	res, err := ec.unmarshalInputBugChangeLabelInput(ctx, v)
	return &res, graphql.ErrorOnPath(ctx, err)
}

// endregion ***************************** type.gotpl *****************************