package integration

// Code generated by github.com/Khan/genqlient, DO NOT EDIT.

import (
	"context"
	"encoding/json"
	"fmt"
	"time"

	"github.com/Khan/genqlient/graphql"
	"github.com/Khan/genqlient/internal/testutil"
)

// AnimalFields includes the GraphQL fields of Animal requested by the fragment AnimalFields.
type AnimalFields struct {
	Id    string                     `json:"id"`
	Hair  AnimalFieldsHairBeingsHair `json:"hair"`
	Owner AnimalFieldsOwnerBeing     `json:"-"`
}

func (v *AnimalFields) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*AnimalFields
		Owner json.RawMessage `json:"owner"`
		graphql.NoUnmarshalJSON
	}
	firstPass.AnimalFields = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Owner
		src := firstPass.Owner
		err = __unmarshalAnimalFieldsOwnerBeing(
			src, dst)
		if err != nil {
			return fmt.Errorf(
				"Unable to unmarshal AnimalFields.Owner: %w", err)
		}
	}
	return nil
}

// AnimalFieldsHairBeingsHair includes the requested fields of the GraphQL type BeingsHair.
type AnimalFieldsHairBeingsHair struct {
	HasHair bool `json:"hasHair"`
}

// AnimalFieldsOwnerAnimal includes the requested fields of the GraphQL type Animal.
type AnimalFieldsOwnerAnimal struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
}

// AnimalFieldsOwnerBeing includes the requested fields of the GraphQL interface Being.
//
// AnimalFieldsOwnerBeing is implemented by the following types:
// AnimalFieldsOwnerUser
// AnimalFieldsOwnerAnimal
type AnimalFieldsOwnerBeing interface {
	implementsGraphQLInterfaceAnimalFieldsOwnerBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
}

func (v *AnimalFieldsOwnerUser) implementsGraphQLInterfaceAnimalFieldsOwnerBeing() {}

// GetTypename is a part of, and documented with, the interface AnimalFieldsOwnerBeing.
func (v *AnimalFieldsOwnerUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface AnimalFieldsOwnerBeing.
func (v *AnimalFieldsOwnerUser) GetId() string { return v.Id }

func (v *AnimalFieldsOwnerAnimal) implementsGraphQLInterfaceAnimalFieldsOwnerBeing() {}

// GetTypename is a part of, and documented with, the interface AnimalFieldsOwnerBeing.
func (v *AnimalFieldsOwnerAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface AnimalFieldsOwnerBeing.
func (v *AnimalFieldsOwnerAnimal) GetId() string { return v.Id }

func __unmarshalAnimalFieldsOwnerBeing(b []byte, v *AnimalFieldsOwnerBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(AnimalFieldsOwnerUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(AnimalFieldsOwnerAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for AnimalFieldsOwnerBeing: "%v"`, tn.TypeName)
	}
}

// AnimalFieldsOwnerUser includes the requested fields of the GraphQL type User.
type AnimalFieldsOwnerUser struct {
	Typename        string `json:"__typename"`
	Id              string `json:"id"`
	UserFields      `json:"-"`
	LuckyFieldsUser `json:"-"`
}

func (v *AnimalFieldsOwnerUser) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*AnimalFieldsOwnerUser
		graphql.NoUnmarshalJSON
	}
	firstPass.AnimalFieldsOwnerUser = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	err = json.Unmarshal(
		b, &v.UserFields)
	if err != nil {
		return err
	}
	err = json.Unmarshal(
		b, &v.LuckyFieldsUser)
	if err != nil {
		return err
	}
	return nil
}

// LuckyFields includes the GraphQL fields of Lucky requested by the fragment LuckyFields.
//
// LuckyFields is implemented by the following types:
// LuckyFieldsUser
type LuckyFields interface {
	implementsGraphQLInterfaceLuckyFields()
	// GetLuckyNumber returns the interface-field "luckyNumber" from its implementation.
	GetLuckyNumber() int
}

func (v *LuckyFieldsUser) implementsGraphQLInterfaceLuckyFields() {}

// GetLuckyNumber is a part of, and documented with, the interface LuckyFields.
func (v *LuckyFieldsUser) GetLuckyNumber() int { return v.LuckyNumber }

func __unmarshalLuckyFields(b []byte, v *LuckyFields) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(LuckyFieldsUser)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Lucky.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for LuckyFields: "%v"`, tn.TypeName)
	}
}

// LuckyFields includes the GraphQL fields of User requested by the fragment LuckyFields.
type LuckyFieldsUser struct {
	MoreUserFields `json:"-"`
	LuckyNumber    int `json:"luckyNumber"`
}

func (v *LuckyFieldsUser) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*LuckyFieldsUser
		graphql.NoUnmarshalJSON
	}
	firstPass.LuckyFieldsUser = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	err = json.Unmarshal(
		b, &v.MoreUserFields)
	if err != nil {
		return err
	}
	return nil
}

// MoreUserFields includes the GraphQL fields of User requested by the fragment MoreUserFields.
type MoreUserFields struct {
	Id   string             `json:"id"`
	Hair MoreUserFieldsHair `json:"hair"`
}

// MoreUserFieldsHair includes the requested fields of the GraphQL type Hair.
type MoreUserFieldsHair struct {
	Color string `json:"color"`
}

type Species string

const (
	SpeciesDog        Species = "DOG"
	SpeciesCoelacanth Species = "COELACANTH"
)

// UserFields includes the GraphQL fields of User requested by the fragment UserFields.
type UserFields struct {
	Id              string `json:"id"`
	LuckyFieldsUser `json:"-"`
	MoreUserFields  `json:"-"`
}

func (v *UserFields) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*UserFields
		graphql.NoUnmarshalJSON
	}
	firstPass.UserFields = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	err = json.Unmarshal(
		b, &v.LuckyFieldsUser)
	if err != nil {
		return err
	}
	err = json.Unmarshal(
		b, &v.MoreUserFields)
	if err != nil {
		return err
	}
	return nil
}

// __queryWithCustomMarshalInput is used internally by genqlient
type __queryWithCustomMarshalInput struct {
	Date time.Time `json:"-"`
}

func (v *__queryWithCustomMarshalInput) MarshalJSON() ([]byte, error) {

	var fullObject struct {
		*__queryWithCustomMarshalInput
		Date json.RawMessage `json:"date"`
		graphql.NoMarshalJSON
	}
	fullObject.__queryWithCustomMarshalInput = v

	{

		dst := &fullObject.Date
		src := v.Date
		var err error
		*dst, err = testutil.MarshalDate(
			&src)
		if err != nil {
			return nil, fmt.Errorf(
				"Unable to marshal __queryWithCustomMarshalInput.Date: %w", err)
		}
	}

	return json.Marshal(&fullObject)
}

// __queryWithCustomMarshalSliceInput is used internally by genqlient
type __queryWithCustomMarshalSliceInput struct {
	Dates []time.Time `json:"-"`
}

func (v *__queryWithCustomMarshalSliceInput) MarshalJSON() ([]byte, error) {

	var fullObject struct {
		*__queryWithCustomMarshalSliceInput
		Dates []json.RawMessage `json:"dates"`
		graphql.NoMarshalJSON
	}
	fullObject.__queryWithCustomMarshalSliceInput = v

	{

		dst := &fullObject.Dates
		src := v.Dates
		*dst = make(
			[]json.RawMessage,
			len(src))
		for i, src := range src {
			dst := &(*dst)[i]
			var err error
			*dst, err = testutil.MarshalDate(
				&src)
			if err != nil {
				return nil, fmt.Errorf(
					"Unable to marshal __queryWithCustomMarshalSliceInput.Dates: %w", err)
			}
		}
	}

	return json.Marshal(&fullObject)
}

// __queryWithFragmentsInput is used internally by genqlient
type __queryWithFragmentsInput struct {
	Ids []string `json:"ids"`
}

// __queryWithInterfaceListFieldInput is used internally by genqlient
type __queryWithInterfaceListFieldInput struct {
	Ids []string `json:"ids"`
}

// __queryWithInterfaceListPointerFieldInput is used internally by genqlient
type __queryWithInterfaceListPointerFieldInput struct {
	Ids []string `json:"ids"`
}

// __queryWithInterfaceNoFragmentsInput is used internally by genqlient
type __queryWithInterfaceNoFragmentsInput struct {
	Id string `json:"id"`
}

// __queryWithNamedFragmentsInput is used internally by genqlient
type __queryWithNamedFragmentsInput struct {
	Ids []string `json:"ids"`
}

// __queryWithOmitemptyInput is used internally by genqlient
type __queryWithOmitemptyInput struct {
	Id string `json:"id,omitempty"`
}

// __queryWithVariablesInput is used internally by genqlient
type __queryWithVariablesInput struct {
	Id string `json:"id"`
}

// failingQueryMeUser includes the requested fields of the GraphQL type User.
type failingQueryMeUser struct {
	Id string `json:"id"`
}

// failingQueryResponse is returned by failingQuery on success.
type failingQueryResponse struct {
	Fail bool               `json:"fail"`
	Me   failingQueryMeUser `json:"me"`
}

// queryWithCustomMarshalResponse is returned by queryWithCustomMarshal on success.
type queryWithCustomMarshalResponse struct {
	UsersBornOn []queryWithCustomMarshalUsersBornOnUser `json:"usersBornOn"`
}

// queryWithCustomMarshalSliceResponse is returned by queryWithCustomMarshalSlice on success.
type queryWithCustomMarshalSliceResponse struct {
	UsersBornOnDates []queryWithCustomMarshalSliceUsersBornOnDatesUser `json:"usersBornOnDates"`
}

// queryWithCustomMarshalSliceUsersBornOnDatesUser includes the requested fields of the GraphQL type User.
type queryWithCustomMarshalSliceUsersBornOnDatesUser struct {
	Id        string    `json:"id"`
	Name      string    `json:"name"`
	Birthdate time.Time `json:"-"`
}

func (v *queryWithCustomMarshalSliceUsersBornOnDatesUser) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithCustomMarshalSliceUsersBornOnDatesUser
		Birthdate json.RawMessage `json:"birthdate"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithCustomMarshalSliceUsersBornOnDatesUser = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Birthdate
		src := firstPass.Birthdate
		err = testutil.UnmarshalDate(
			src, dst)
		if err != nil {
			return fmt.Errorf(
				"Unable to unmarshal queryWithCustomMarshalSliceUsersBornOnDatesUser.Birthdate: %w", err)
		}
	}
	return nil
}

// queryWithCustomMarshalUsersBornOnUser includes the requested fields of the GraphQL type User.
type queryWithCustomMarshalUsersBornOnUser struct {
	Id        string    `json:"id"`
	Name      string    `json:"name"`
	Birthdate time.Time `json:"-"`
}

func (v *queryWithCustomMarshalUsersBornOnUser) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithCustomMarshalUsersBornOnUser
		Birthdate json.RawMessage `json:"birthdate"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithCustomMarshalUsersBornOnUser = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Birthdate
		src := firstPass.Birthdate
		err = testutil.UnmarshalDate(
			src, dst)
		if err != nil {
			return fmt.Errorf(
				"Unable to unmarshal queryWithCustomMarshalUsersBornOnUser.Birthdate: %w", err)
		}
	}
	return nil
}

// queryWithFragmentsBeingsAnimal includes the requested fields of the GraphQL type Animal.
type queryWithFragmentsBeingsAnimal struct {
	Typename string                                       `json:"__typename"`
	Id       string                                       `json:"id"`
	Name     string                                       `json:"name"`
	Hair     queryWithFragmentsBeingsAnimalHairBeingsHair `json:"hair"`
	Species  Species                                      `json:"species"`
	Owner    queryWithFragmentsBeingsAnimalOwnerBeing     `json:"-"`
}

func (v *queryWithFragmentsBeingsAnimal) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithFragmentsBeingsAnimal
		Owner json.RawMessage `json:"owner"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithFragmentsBeingsAnimal = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Owner
		src := firstPass.Owner
		err = __unmarshalqueryWithFragmentsBeingsAnimalOwnerBeing(
			src, dst)
		if err != nil {
			return fmt.Errorf(
				"Unable to unmarshal queryWithFragmentsBeingsAnimal.Owner: %w", err)
		}
	}
	return nil
}

// queryWithFragmentsBeingsAnimalHairBeingsHair includes the requested fields of the GraphQL type BeingsHair.
type queryWithFragmentsBeingsAnimalHairBeingsHair struct {
	HasHair bool `json:"hasHair"`
}

// queryWithFragmentsBeingsAnimalOwnerAnimal includes the requested fields of the GraphQL type Animal.
type queryWithFragmentsBeingsAnimalOwnerAnimal struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithFragmentsBeingsAnimalOwnerBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithFragmentsBeingsAnimalOwnerBeing is implemented by the following types:
// queryWithFragmentsBeingsAnimalOwnerUser
// queryWithFragmentsBeingsAnimalOwnerAnimal
type queryWithFragmentsBeingsAnimalOwnerBeing interface {
	implementsGraphQLInterfacequeryWithFragmentsBeingsAnimalOwnerBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
	// GetName returns the interface-field "name" from its implementation.
	GetName() string
}

func (v *queryWithFragmentsBeingsAnimalOwnerUser) implementsGraphQLInterfacequeryWithFragmentsBeingsAnimalOwnerBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerUser) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerUser) GetName() string { return v.Name }

func (v *queryWithFragmentsBeingsAnimalOwnerAnimal) implementsGraphQLInterfacequeryWithFragmentsBeingsAnimalOwnerBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerAnimal) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithFragmentsBeingsAnimalOwnerBeing.
func (v *queryWithFragmentsBeingsAnimalOwnerAnimal) GetName() string { return v.Name }

func __unmarshalqueryWithFragmentsBeingsAnimalOwnerBeing(b []byte, v *queryWithFragmentsBeingsAnimalOwnerBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithFragmentsBeingsAnimalOwnerUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithFragmentsBeingsAnimalOwnerAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithFragmentsBeingsAnimalOwnerBeing: "%v"`, tn.TypeName)
	}
}

// queryWithFragmentsBeingsAnimalOwnerUser includes the requested fields of the GraphQL type User.
type queryWithFragmentsBeingsAnimalOwnerUser struct {
	Typename    string `json:"__typename"`
	Id          string `json:"id"`
	Name        string `json:"name"`
	LuckyNumber int    `json:"luckyNumber"`
}

// queryWithFragmentsBeingsBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithFragmentsBeingsBeing is implemented by the following types:
// queryWithFragmentsBeingsUser
// queryWithFragmentsBeingsAnimal
type queryWithFragmentsBeingsBeing interface {
	implementsGraphQLInterfacequeryWithFragmentsBeingsBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
	// GetName returns the interface-field "name" from its implementation.
	GetName() string
}

func (v *queryWithFragmentsBeingsUser) implementsGraphQLInterfacequeryWithFragmentsBeingsBeing() {}

// GetTypename is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsUser) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsUser) GetName() string { return v.Name }

func (v *queryWithFragmentsBeingsAnimal) implementsGraphQLInterfacequeryWithFragmentsBeingsBeing() {}

// GetTypename is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsAnimal) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithFragmentsBeingsBeing.
func (v *queryWithFragmentsBeingsAnimal) GetName() string { return v.Name }

func __unmarshalqueryWithFragmentsBeingsBeing(b []byte, v *queryWithFragmentsBeingsBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithFragmentsBeingsUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithFragmentsBeingsAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithFragmentsBeingsBeing: "%v"`, tn.TypeName)
	}
}

// queryWithFragmentsBeingsUser includes the requested fields of the GraphQL type User.
type queryWithFragmentsBeingsUser struct {
	Typename    string                           `json:"__typename"`
	Id          string                           `json:"id"`
	Name        string                           `json:"name"`
	LuckyNumber int                              `json:"luckyNumber"`
	Hair        queryWithFragmentsBeingsUserHair `json:"hair"`
}

// queryWithFragmentsBeingsUserHair includes the requested fields of the GraphQL type Hair.
type queryWithFragmentsBeingsUserHair struct {
	Color string `json:"color"`
}

// queryWithFragmentsResponse is returned by queryWithFragments on success.
type queryWithFragmentsResponse struct {
	Beings []queryWithFragmentsBeingsBeing `json:"-"`
}

func (v *queryWithFragmentsResponse) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithFragmentsResponse
		Beings []json.RawMessage `json:"beings"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithFragmentsResponse = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Beings
		src := firstPass.Beings
		*dst = make(
			[]queryWithFragmentsBeingsBeing,
			len(src))
		for i, src := range src {
			dst := &(*dst)[i]
			err = __unmarshalqueryWithFragmentsBeingsBeing(
				src, dst)
			if err != nil {
				return fmt.Errorf(
					"Unable to unmarshal queryWithFragmentsResponse.Beings: %w", err)
			}
		}
	}
	return nil
}

// queryWithInterfaceListFieldBeingsAnimal includes the requested fields of the GraphQL type Animal.
type queryWithInterfaceListFieldBeingsAnimal struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceListFieldBeingsBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithInterfaceListFieldBeingsBeing is implemented by the following types:
// queryWithInterfaceListFieldBeingsUser
// queryWithInterfaceListFieldBeingsAnimal
type queryWithInterfaceListFieldBeingsBeing interface {
	implementsGraphQLInterfacequeryWithInterfaceListFieldBeingsBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
	// GetName returns the interface-field "name" from its implementation.
	GetName() string
}

func (v *queryWithInterfaceListFieldBeingsUser) implementsGraphQLInterfacequeryWithInterfaceListFieldBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsUser) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsUser) GetName() string { return v.Name }

func (v *queryWithInterfaceListFieldBeingsAnimal) implementsGraphQLInterfacequeryWithInterfaceListFieldBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsAnimal) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceListFieldBeingsBeing.
func (v *queryWithInterfaceListFieldBeingsAnimal) GetName() string { return v.Name }

func __unmarshalqueryWithInterfaceListFieldBeingsBeing(b []byte, v *queryWithInterfaceListFieldBeingsBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithInterfaceListFieldBeingsUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithInterfaceListFieldBeingsAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithInterfaceListFieldBeingsBeing: "%v"`, tn.TypeName)
	}
}

// queryWithInterfaceListFieldBeingsUser includes the requested fields of the GraphQL type User.
type queryWithInterfaceListFieldBeingsUser struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceListFieldResponse is returned by queryWithInterfaceListField on success.
type queryWithInterfaceListFieldResponse struct {
	Beings []queryWithInterfaceListFieldBeingsBeing `json:"-"`
}

func (v *queryWithInterfaceListFieldResponse) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithInterfaceListFieldResponse
		Beings []json.RawMessage `json:"beings"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithInterfaceListFieldResponse = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Beings
		src := firstPass.Beings
		*dst = make(
			[]queryWithInterfaceListFieldBeingsBeing,
			len(src))
		for i, src := range src {
			dst := &(*dst)[i]
			err = __unmarshalqueryWithInterfaceListFieldBeingsBeing(
				src, dst)
			if err != nil {
				return fmt.Errorf(
					"Unable to unmarshal queryWithInterfaceListFieldResponse.Beings: %w", err)
			}
		}
	}
	return nil
}

// queryWithInterfaceListPointerFieldBeingsAnimal includes the requested fields of the GraphQL type Animal.
type queryWithInterfaceListPointerFieldBeingsAnimal struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceListPointerFieldBeingsBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithInterfaceListPointerFieldBeingsBeing is implemented by the following types:
// queryWithInterfaceListPointerFieldBeingsUser
// queryWithInterfaceListPointerFieldBeingsAnimal
type queryWithInterfaceListPointerFieldBeingsBeing interface {
	implementsGraphQLInterfacequeryWithInterfaceListPointerFieldBeingsBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
	// GetName returns the interface-field "name" from its implementation.
	GetName() string
}

func (v *queryWithInterfaceListPointerFieldBeingsUser) implementsGraphQLInterfacequeryWithInterfaceListPointerFieldBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsUser) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsUser) GetName() string { return v.Name }

func (v *queryWithInterfaceListPointerFieldBeingsAnimal) implementsGraphQLInterfacequeryWithInterfaceListPointerFieldBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsAnimal) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceListPointerFieldBeingsBeing.
func (v *queryWithInterfaceListPointerFieldBeingsAnimal) GetName() string { return v.Name }

func __unmarshalqueryWithInterfaceListPointerFieldBeingsBeing(b []byte, v *queryWithInterfaceListPointerFieldBeingsBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithInterfaceListPointerFieldBeingsUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithInterfaceListPointerFieldBeingsAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithInterfaceListPointerFieldBeingsBeing: "%v"`, tn.TypeName)
	}
}

// queryWithInterfaceListPointerFieldBeingsUser includes the requested fields of the GraphQL type User.
type queryWithInterfaceListPointerFieldBeingsUser struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceListPointerFieldResponse is returned by queryWithInterfaceListPointerField on success.
type queryWithInterfaceListPointerFieldResponse struct {
	Beings []*queryWithInterfaceListPointerFieldBeingsBeing `json:"-"`
}

func (v *queryWithInterfaceListPointerFieldResponse) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithInterfaceListPointerFieldResponse
		Beings []json.RawMessage `json:"beings"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithInterfaceListPointerFieldResponse = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Beings
		src := firstPass.Beings
		*dst = make(
			[]*queryWithInterfaceListPointerFieldBeingsBeing,
			len(src))
		for i, src := range src {
			dst := &(*dst)[i]
			*dst = new(queryWithInterfaceListPointerFieldBeingsBeing)
			err = __unmarshalqueryWithInterfaceListPointerFieldBeingsBeing(
				src, *dst)
			if err != nil {
				return fmt.Errorf(
					"Unable to unmarshal queryWithInterfaceListPointerFieldResponse.Beings: %w", err)
			}
		}
	}
	return nil
}

// queryWithInterfaceNoFragmentsBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithInterfaceNoFragmentsBeing is implemented by the following types:
// queryWithInterfaceNoFragmentsBeingUser
// queryWithInterfaceNoFragmentsBeingAnimal
type queryWithInterfaceNoFragmentsBeing interface {
	implementsGraphQLInterfacequeryWithInterfaceNoFragmentsBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
	// GetName returns the interface-field "name" from its implementation.
	GetName() string
}

func (v *queryWithInterfaceNoFragmentsBeingUser) implementsGraphQLInterfacequeryWithInterfaceNoFragmentsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingUser) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingUser) GetName() string { return v.Name }

func (v *queryWithInterfaceNoFragmentsBeingAnimal) implementsGraphQLInterfacequeryWithInterfaceNoFragmentsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingAnimal) GetId() string { return v.Id }

// GetName is a part of, and documented with, the interface queryWithInterfaceNoFragmentsBeing.
func (v *queryWithInterfaceNoFragmentsBeingAnimal) GetName() string { return v.Name }

func __unmarshalqueryWithInterfaceNoFragmentsBeing(b []byte, v *queryWithInterfaceNoFragmentsBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithInterfaceNoFragmentsBeingUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithInterfaceNoFragmentsBeingAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithInterfaceNoFragmentsBeing: "%v"`, tn.TypeName)
	}
}

// queryWithInterfaceNoFragmentsBeingAnimal includes the requested fields of the GraphQL type Animal.
type queryWithInterfaceNoFragmentsBeingAnimal struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceNoFragmentsBeingUser includes the requested fields of the GraphQL type User.
type queryWithInterfaceNoFragmentsBeingUser struct {
	Typename string `json:"__typename"`
	Id       string `json:"id"`
	Name     string `json:"name"`
}

// queryWithInterfaceNoFragmentsMeUser includes the requested fields of the GraphQL type User.
type queryWithInterfaceNoFragmentsMeUser struct {
	Id   string `json:"id"`
	Name string `json:"name"`
}

// queryWithInterfaceNoFragmentsResponse is returned by queryWithInterfaceNoFragments on success.
type queryWithInterfaceNoFragmentsResponse struct {
	Being queryWithInterfaceNoFragmentsBeing  `json:"-"`
	Me    queryWithInterfaceNoFragmentsMeUser `json:"me"`
}

func (v *queryWithInterfaceNoFragmentsResponse) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithInterfaceNoFragmentsResponse
		Being json.RawMessage `json:"being"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithInterfaceNoFragmentsResponse = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Being
		src := firstPass.Being
		err = __unmarshalqueryWithInterfaceNoFragmentsBeing(
			src, dst)
		if err != nil {
			return fmt.Errorf(
				"Unable to unmarshal queryWithInterfaceNoFragmentsResponse.Being: %w", err)
		}
	}
	return nil
}

// queryWithNamedFragmentsBeingsAnimal includes the requested fields of the GraphQL type Animal.
type queryWithNamedFragmentsBeingsAnimal struct {
	Typename     string `json:"__typename"`
	Id           string `json:"id"`
	AnimalFields `json:"-"`
}

func (v *queryWithNamedFragmentsBeingsAnimal) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithNamedFragmentsBeingsAnimal
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithNamedFragmentsBeingsAnimal = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	err = json.Unmarshal(
		b, &v.AnimalFields)
	if err != nil {
		return err
	}
	return nil
}

// queryWithNamedFragmentsBeingsBeing includes the requested fields of the GraphQL interface Being.
//
// queryWithNamedFragmentsBeingsBeing is implemented by the following types:
// queryWithNamedFragmentsBeingsUser
// queryWithNamedFragmentsBeingsAnimal
type queryWithNamedFragmentsBeingsBeing interface {
	implementsGraphQLInterfacequeryWithNamedFragmentsBeingsBeing()
	// GetTypename returns the receiver's concrete GraphQL type-name (see interface doc for possible values).
	GetTypename() string
	// GetId returns the interface-field "id" from its implementation.
	GetId() string
}

func (v *queryWithNamedFragmentsBeingsUser) implementsGraphQLInterfacequeryWithNamedFragmentsBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithNamedFragmentsBeingsBeing.
func (v *queryWithNamedFragmentsBeingsUser) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithNamedFragmentsBeingsBeing.
func (v *queryWithNamedFragmentsBeingsUser) GetId() string { return v.Id }

func (v *queryWithNamedFragmentsBeingsAnimal) implementsGraphQLInterfacequeryWithNamedFragmentsBeingsBeing() {
}

// GetTypename is a part of, and documented with, the interface queryWithNamedFragmentsBeingsBeing.
func (v *queryWithNamedFragmentsBeingsAnimal) GetTypename() string { return v.Typename }

// GetId is a part of, and documented with, the interface queryWithNamedFragmentsBeingsBeing.
func (v *queryWithNamedFragmentsBeingsAnimal) GetId() string { return v.Id }

func __unmarshalqueryWithNamedFragmentsBeingsBeing(b []byte, v *queryWithNamedFragmentsBeingsBeing) error {
	if string(b) == "null" {
		return nil
	}

	var tn struct {
		TypeName string `json:"__typename"`
	}
	err := json.Unmarshal(b, &tn)
	if err != nil {
		return err
	}

	switch tn.TypeName {
	case "User":
		*v = new(queryWithNamedFragmentsBeingsUser)
		return json.Unmarshal(b, *v)
	case "Animal":
		*v = new(queryWithNamedFragmentsBeingsAnimal)
		return json.Unmarshal(b, *v)
	case "":
		return fmt.Errorf(
			"Response was missing Being.__typename")
	default:
		return fmt.Errorf(
			`Unexpected concrete type for queryWithNamedFragmentsBeingsBeing: "%v"`, tn.TypeName)
	}
}

// queryWithNamedFragmentsBeingsUser includes the requested fields of the GraphQL type User.
type queryWithNamedFragmentsBeingsUser struct {
	Typename   string `json:"__typename"`
	Id         string `json:"id"`
	UserFields `json:"-"`
}

func (v *queryWithNamedFragmentsBeingsUser) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithNamedFragmentsBeingsUser
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithNamedFragmentsBeingsUser = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	err = json.Unmarshal(
		b, &v.UserFields)
	if err != nil {
		return err
	}
	return nil
}

// queryWithNamedFragmentsResponse is returned by queryWithNamedFragments on success.
type queryWithNamedFragmentsResponse struct {
	Beings []queryWithNamedFragmentsBeingsBeing `json:"-"`
}

func (v *queryWithNamedFragmentsResponse) UnmarshalJSON(b []byte) error {

	if string(b) == "null" {
		return nil
	}

	var firstPass struct {
		*queryWithNamedFragmentsResponse
		Beings []json.RawMessage `json:"beings"`
		graphql.NoUnmarshalJSON
	}
	firstPass.queryWithNamedFragmentsResponse = v

	err := json.Unmarshal(b, &firstPass)
	if err != nil {
		return err
	}

	{
		dst := &v.Beings
		src := firstPass.Beings
		*dst = make(
			[]queryWithNamedFragmentsBeingsBeing,
			len(src))
		for i, src := range src {
			dst := &(*dst)[i]
			err = __unmarshalqueryWithNamedFragmentsBeingsBeing(
				src, dst)
			if err != nil {
				return fmt.Errorf(
					"Unable to unmarshal queryWithNamedFragmentsResponse.Beings: %w", err)
			}
		}
	}
	return nil
}

// queryWithOmitemptyResponse is returned by queryWithOmitempty on success.
type queryWithOmitemptyResponse struct {
	User queryWithOmitemptyUser `json:"user"`
}

// queryWithOmitemptyUser includes the requested fields of the GraphQL type User.
type queryWithOmitemptyUser struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	LuckyNumber int    `json:"luckyNumber"`
}

// queryWithVariablesResponse is returned by queryWithVariables on success.
type queryWithVariablesResponse struct {
	User queryWithVariablesUser `json:"user"`
}

// queryWithVariablesUser includes the requested fields of the GraphQL type User.
type queryWithVariablesUser struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	LuckyNumber int    `json:"luckyNumber"`
}

// simpleQueryMeUser includes the requested fields of the GraphQL type User.
type simpleQueryMeUser struct {
	Id          string `json:"id"`
	Name        string `json:"name"`
	LuckyNumber int    `json:"luckyNumber"`
}

// simpleQueryResponse is returned by simpleQuery on success.
type simpleQueryResponse struct {
	Me simpleQueryMeUser `json:"me"`
}

func simpleQuery(
	ctx context.Context,
	client graphql.Client,
) (*simpleQueryResponse, error) {
	var err error

	var retval simpleQueryResponse
	err = client.MakeRequest(
		ctx,
		"simpleQuery",
		`
query simpleQuery {
	me {
		id
		name
		luckyNumber
	}
}
`,
		&retval,
		nil,
	)
	return &retval, err
}

func failingQuery(
	ctx context.Context,
	client graphql.Client,
) (*failingQueryResponse, error) {
	var err error

	var retval failingQueryResponse
	err = client.MakeRequest(
		ctx,
		"failingQuery",
		`
query failingQuery {
	fail
	me {
		id
	}
}
`,
		&retval,
		nil,
	)
	return &retval, err
}

func queryWithVariables(
	ctx context.Context,
	client graphql.Client,
	id string,
) (*queryWithVariablesResponse, error) {
	__input := __queryWithVariablesInput{
		Id: id,
	}
	var err error

	var retval queryWithVariablesResponse
	err = client.MakeRequest(
		ctx,
		"queryWithVariables",
		`
query queryWithVariables ($id: ID!) {
	user(id: $id) {
		id
		name
		luckyNumber
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithOmitempty(
	ctx context.Context,
	client graphql.Client,
	id string,
) (*queryWithOmitemptyResponse, error) {
	__input := __queryWithOmitemptyInput{
		Id: id,
	}
	var err error

	var retval queryWithOmitemptyResponse
	err = client.MakeRequest(
		ctx,
		"queryWithOmitempty",
		`
query queryWithOmitempty ($id: ID) {
	user(id: $id) {
		id
		name
		luckyNumber
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithCustomMarshal(
	ctx context.Context,
	client graphql.Client,
	date time.Time,
) (*queryWithCustomMarshalResponse, error) {
	__input := __queryWithCustomMarshalInput{
		Date: date,
	}
	var err error

	var retval queryWithCustomMarshalResponse
	err = client.MakeRequest(
		ctx,
		"queryWithCustomMarshal",
		`
query queryWithCustomMarshal ($date: Date!) {
	usersBornOn(date: $date) {
		id
		name
		birthdate
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithCustomMarshalSlice(
	ctx context.Context,
	client graphql.Client,
	dates []time.Time,
) (*queryWithCustomMarshalSliceResponse, error) {
	__input := __queryWithCustomMarshalSliceInput{
		Dates: dates,
	}
	var err error

	var retval queryWithCustomMarshalSliceResponse
	err = client.MakeRequest(
		ctx,
		"queryWithCustomMarshalSlice",
		`
query queryWithCustomMarshalSlice ($dates: [Date!]!) {
	usersBornOnDates(dates: $dates) {
		id
		name
		birthdate
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithInterfaceNoFragments(
	ctx context.Context,
	client graphql.Client,
	id string,
) (*queryWithInterfaceNoFragmentsResponse, error) {
	__input := __queryWithInterfaceNoFragmentsInput{
		Id: id,
	}
	var err error

	var retval queryWithInterfaceNoFragmentsResponse
	err = client.MakeRequest(
		ctx,
		"queryWithInterfaceNoFragments",
		`
query queryWithInterfaceNoFragments ($id: ID!) {
	being(id: $id) {
		__typename
		id
		name
	}
	me {
		id
		name
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithInterfaceListField(
	ctx context.Context,
	client graphql.Client,
	ids []string,
) (*queryWithInterfaceListFieldResponse, error) {
	__input := __queryWithInterfaceListFieldInput{
		Ids: ids,
	}
	var err error

	var retval queryWithInterfaceListFieldResponse
	err = client.MakeRequest(
		ctx,
		"queryWithInterfaceListField",
		`
query queryWithInterfaceListField ($ids: [ID!]!) {
	beings(ids: $ids) {
		__typename
		id
		name
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithInterfaceListPointerField(
	ctx context.Context,
	client graphql.Client,
	ids []string,
) (*queryWithInterfaceListPointerFieldResponse, error) {
	__input := __queryWithInterfaceListPointerFieldInput{
		Ids: ids,
	}
	var err error

	var retval queryWithInterfaceListPointerFieldResponse
	err = client.MakeRequest(
		ctx,
		"queryWithInterfaceListPointerField",
		`
query queryWithInterfaceListPointerField ($ids: [ID!]!) {
	beings(ids: $ids) {
		__typename
		id
		name
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithFragments(
	ctx context.Context,
	client graphql.Client,
	ids []string,
) (*queryWithFragmentsResponse, error) {
	__input := __queryWithFragmentsInput{
		Ids: ids,
	}
	var err error

	var retval queryWithFragmentsResponse
	err = client.MakeRequest(
		ctx,
		"queryWithFragments",
		`
query queryWithFragments ($ids: [ID!]!) {
	beings(ids: $ids) {
		__typename
		id
		... on Being {
			id
			name
		}
		... on Animal {
			id
			hair {
				hasHair
			}
			species
			owner {
				__typename
				id
				... on Being {
					name
				}
				... on User {
					luckyNumber
				}
			}
		}
		... on Lucky {
			luckyNumber
		}
		... on User {
			hair {
				color
			}
		}
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}

func queryWithNamedFragments(
	ctx context.Context,
	client graphql.Client,
	ids []string,
) (*queryWithNamedFragmentsResponse, error) {
	__input := __queryWithNamedFragmentsInput{
		Ids: ids,
	}
	var err error

	var retval queryWithNamedFragmentsResponse
	err = client.MakeRequest(
		ctx,
		"queryWithNamedFragments",
		`
query queryWithNamedFragments ($ids: [ID!]!) {
	beings(ids: $ids) {
		__typename
		id
		... AnimalFields
		... UserFields
	}
}
fragment AnimalFields on Animal {
	id
	hair {
		hasHair
	}
	owner {
		__typename
		id
		... UserFields
		... LuckyFields
	}
}
fragment UserFields on User {
	id
	... LuckyFields
	... MoreUserFields
}
fragment LuckyFields on Lucky {
	... MoreUserFields
	luckyNumber
}
fragment MoreUserFields on User {
	id
	hair {
		color
	}
}
`,
		&retval,
		&__input,
	)
	return &retval, err
}