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

package generated

import (
	"bytes"
	"context"
	"errors"
	"sync/atomic"

	"code.icod.de/dalu/ka/ent"
	"entgo.io/contrib/entgql"
	"github.com/99designs/gqlgen/graphql"
	"github.com/99designs/gqlgen/graphql/introspection"
	"github.com/google/uuid"
	gqlparser "github.com/vektah/gqlparser/v2"
	"github.com/vektah/gqlparser/v2/ast"
)

// NewExecutableSchema creates an ExecutableSchema from the ResolverRoot interface.
func NewExecutableSchema(cfg Config) graphql.ExecutableSchema {
	return &executableSchema{
		schema:     cfg.Schema,
		resolvers:  cfg.Resolvers,
		directives: cfg.Directives,
		complexity: cfg.Complexity,
	}
}

type Config struct {
	Schema     *ast.Schema
	Resolvers  ResolverRoot
	Directives DirectiveRoot
	Complexity ComplexityRoot
}

type ResolverRoot interface {
	Query() QueryResolver
}

type DirectiveRoot struct {
}

type ComplexityRoot struct {
	Category struct {
		CreatedAt   func(childComplexity int) int
		Description func(childComplexity int) int
		ID          func(childComplexity int) int
		Posts       func(childComplexity int, after *entgql.Cursor[uuid.UUID], first *int, before *entgql.Cursor[uuid.UUID], last *int, orderBy *ent.PostOrder, where *ent.PostWhereInput) int
		Title       func(childComplexity int) int
		UpdatedAt   func(childComplexity int) int
	}

	CategoryConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	CategoryEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	PageInfo struct {
		EndCursor       func(childComplexity int) int
		HasNextPage     func(childComplexity int) int
		HasPreviousPage func(childComplexity int) int
		StartCursor     func(childComplexity int) int
	}

	Post struct {
		Body       func(childComplexity int) int
		Category   func(childComplexity int) int
		CreatedAt  func(childComplexity int) int
		ExpireTime func(childComplexity int) int
		Expires    func(childComplexity int) int
		ID         func(childComplexity int) int
		Profile    func(childComplexity int) int
		Title      func(childComplexity int) int
		UpdatedAt  func(childComplexity int) int
	}

	PostConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	PostEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	Profile struct {
		Address   func(childComplexity int) int
		CreatedAt func(childComplexity int) int
		ID        func(childComplexity int) int
		Name      func(childComplexity int) int
		Phone     func(childComplexity int) int
		Posts     func(childComplexity int, after *entgql.Cursor[uuid.UUID], first *int, before *entgql.Cursor[uuid.UUID], last *int, orderBy *ent.PostOrder, where *ent.PostWhereInput) int
		UpdatedAt func(childComplexity int) int
	}

	ProfileConnection struct {
		Edges      func(childComplexity int) int
		PageInfo   func(childComplexity int) int
		TotalCount func(childComplexity int) int
	}

	ProfileEdge struct {
		Cursor func(childComplexity int) int
		Node   func(childComplexity int) int
	}

	Query struct {
		Categories func(childComplexity int, after *entgql.Cursor[uuid.UUID], first *int, before *entgql.Cursor[uuid.UUID], last *int, orderBy *ent.CategoryOrder, where *ent.CategoryWhereInput) int
		Node       func(childComplexity int, id uuid.UUID) int
		Nodes      func(childComplexity int, ids []uuid.UUID) int
		Posts      func(childComplexity int, after *entgql.Cursor[uuid.UUID], first *int, before *entgql.Cursor[uuid.UUID], last *int, orderBy *ent.PostOrder, where *ent.PostWhereInput) int
		Profiles   func(childComplexity int, after *entgql.Cursor[uuid.UUID], first *int, before *entgql.Cursor[uuid.UUID], last *int, orderBy *ent.ProfileOrder, where *ent.ProfileWhereInput) int
	}
}

type executableSchema struct {
	schema     *ast.Schema
	resolvers  ResolverRoot
	directives DirectiveRoot
	complexity ComplexityRoot
}

func (e *executableSchema) Schema() *ast.Schema {
	if e.schema != nil {
		return e.schema
	}
	return parsedSchema
}

func (e *executableSchema) Complexity(typeName, field string, childComplexity int, rawArgs map[string]interface{}) (int, bool) {
	ec := executionContext{nil, e, 0, 0, nil}
	_ = ec
	switch typeName + "." + field {

	case "Category.createdAt":
		if e.complexity.Category.CreatedAt == nil {
			break
		}

		return e.complexity.Category.CreatedAt(childComplexity), true

	case "Category.description":
		if e.complexity.Category.Description == nil {
			break
		}

		return e.complexity.Category.Description(childComplexity), true

	case "Category.id":
		if e.complexity.Category.ID == nil {
			break
		}

		return e.complexity.Category.ID(childComplexity), true

	case "Category.posts":
		if e.complexity.Category.Posts == nil {
			break
		}

		args, err := ec.field_Category_posts_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Category.Posts(childComplexity, args["after"].(*entgql.Cursor[uuid.UUID]), args["first"].(*int), args["before"].(*entgql.Cursor[uuid.UUID]), args["last"].(*int), args["orderBy"].(*ent.PostOrder), args["where"].(*ent.PostWhereInput)), true

	case "Category.title":
		if e.complexity.Category.Title == nil {
			break
		}

		return e.complexity.Category.Title(childComplexity), true

	case "Category.updatedAt":
		if e.complexity.Category.UpdatedAt == nil {
			break
		}

		return e.complexity.Category.UpdatedAt(childComplexity), true

	case "CategoryConnection.edges":
		if e.complexity.CategoryConnection.Edges == nil {
			break
		}

		return e.complexity.CategoryConnection.Edges(childComplexity), true

	case "CategoryConnection.pageInfo":
		if e.complexity.CategoryConnection.PageInfo == nil {
			break
		}

		return e.complexity.CategoryConnection.PageInfo(childComplexity), true

	case "CategoryConnection.totalCount":
		if e.complexity.CategoryConnection.TotalCount == nil {
			break
		}

		return e.complexity.CategoryConnection.TotalCount(childComplexity), true

	case "CategoryEdge.cursor":
		if e.complexity.CategoryEdge.Cursor == nil {
			break
		}

		return e.complexity.CategoryEdge.Cursor(childComplexity), true

	case "CategoryEdge.node":
		if e.complexity.CategoryEdge.Node == nil {
			break
		}

		return e.complexity.CategoryEdge.Node(childComplexity), true

	case "PageInfo.endCursor":
		if e.complexity.PageInfo.EndCursor == nil {
			break
		}

		return e.complexity.PageInfo.EndCursor(childComplexity), true

	case "PageInfo.hasNextPage":
		if e.complexity.PageInfo.HasNextPage == nil {
			break
		}

		return e.complexity.PageInfo.HasNextPage(childComplexity), true

	case "PageInfo.hasPreviousPage":
		if e.complexity.PageInfo.HasPreviousPage == nil {
			break
		}

		return e.complexity.PageInfo.HasPreviousPage(childComplexity), true

	case "PageInfo.startCursor":
		if e.complexity.PageInfo.StartCursor == nil {
			break
		}

		return e.complexity.PageInfo.StartCursor(childComplexity), true

	case "Post.body":
		if e.complexity.Post.Body == nil {
			break
		}

		return e.complexity.Post.Body(childComplexity), true

	case "Post.category":
		if e.complexity.Post.Category == nil {
			break
		}

		return e.complexity.Post.Category(childComplexity), true

	case "Post.createdAt":
		if e.complexity.Post.CreatedAt == nil {
			break
		}

		return e.complexity.Post.CreatedAt(childComplexity), true

	case "Post.expireTime":
		if e.complexity.Post.ExpireTime == nil {
			break
		}

		return e.complexity.Post.ExpireTime(childComplexity), true

	case "Post.expires":
		if e.complexity.Post.Expires == nil {
			break
		}

		return e.complexity.Post.Expires(childComplexity), true

	case "Post.id":
		if e.complexity.Post.ID == nil {
			break
		}

		return e.complexity.Post.ID(childComplexity), true

	case "Post.profile":
		if e.complexity.Post.Profile == nil {
			break
		}

		return e.complexity.Post.Profile(childComplexity), true

	case "Post.title":
		if e.complexity.Post.Title == nil {
			break
		}

		return e.complexity.Post.Title(childComplexity), true

	case "Post.updatedAt":
		if e.complexity.Post.UpdatedAt == nil {
			break
		}

		return e.complexity.Post.UpdatedAt(childComplexity), true

	case "PostConnection.edges":
		if e.complexity.PostConnection.Edges == nil {
			break
		}

		return e.complexity.PostConnection.Edges(childComplexity), true

	case "PostConnection.pageInfo":
		if e.complexity.PostConnection.PageInfo == nil {
			break
		}

		return e.complexity.PostConnection.PageInfo(childComplexity), true

	case "PostConnection.totalCount":
		if e.complexity.PostConnection.TotalCount == nil {
			break
		}

		return e.complexity.PostConnection.TotalCount(childComplexity), true

	case "PostEdge.cursor":
		if e.complexity.PostEdge.Cursor == nil {
			break
		}

		return e.complexity.PostEdge.Cursor(childComplexity), true

	case "PostEdge.node":
		if e.complexity.PostEdge.Node == nil {
			break
		}

		return e.complexity.PostEdge.Node(childComplexity), true

	case "Profile.address":
		if e.complexity.Profile.Address == nil {
			break
		}

		return e.complexity.Profile.Address(childComplexity), true

	case "Profile.createdAt":
		if e.complexity.Profile.CreatedAt == nil {
			break
		}

		return e.complexity.Profile.CreatedAt(childComplexity), true

	case "Profile.id":
		if e.complexity.Profile.ID == nil {
			break
		}

		return e.complexity.Profile.ID(childComplexity), true

	case "Profile.name":
		if e.complexity.Profile.Name == nil {
			break
		}

		return e.complexity.Profile.Name(childComplexity), true

	case "Profile.phone":
		if e.complexity.Profile.Phone == nil {
			break
		}

		return e.complexity.Profile.Phone(childComplexity), true

	case "Profile.posts":
		if e.complexity.Profile.Posts == nil {
			break
		}

		args, err := ec.field_Profile_posts_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Profile.Posts(childComplexity, args["after"].(*entgql.Cursor[uuid.UUID]), args["first"].(*int), args["before"].(*entgql.Cursor[uuid.UUID]), args["last"].(*int), args["orderBy"].(*ent.PostOrder), args["where"].(*ent.PostWhereInput)), true

	case "Profile.updatedAt":
		if e.complexity.Profile.UpdatedAt == nil {
			break
		}

		return e.complexity.Profile.UpdatedAt(childComplexity), true

	case "ProfileConnection.edges":
		if e.complexity.ProfileConnection.Edges == nil {
			break
		}

		return e.complexity.ProfileConnection.Edges(childComplexity), true

	case "ProfileConnection.pageInfo":
		if e.complexity.ProfileConnection.PageInfo == nil {
			break
		}

		return e.complexity.ProfileConnection.PageInfo(childComplexity), true

	case "ProfileConnection.totalCount":
		if e.complexity.ProfileConnection.TotalCount == nil {
			break
		}

		return e.complexity.ProfileConnection.TotalCount(childComplexity), true

	case "ProfileEdge.cursor":
		if e.complexity.ProfileEdge.Cursor == nil {
			break
		}

		return e.complexity.ProfileEdge.Cursor(childComplexity), true

	case "ProfileEdge.node":
		if e.complexity.ProfileEdge.Node == nil {
			break
		}

		return e.complexity.ProfileEdge.Node(childComplexity), true

	case "Query.categories":
		if e.complexity.Query.Categories == nil {
			break
		}

		args, err := ec.field_Query_categories_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Categories(childComplexity, args["after"].(*entgql.Cursor[uuid.UUID]), args["first"].(*int), args["before"].(*entgql.Cursor[uuid.UUID]), args["last"].(*int), args["orderBy"].(*ent.CategoryOrder), args["where"].(*ent.CategoryWhereInput)), true

	case "Query.node":
		if e.complexity.Query.Node == nil {
			break
		}

		args, err := ec.field_Query_node_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Node(childComplexity, args["id"].(uuid.UUID)), true

	case "Query.nodes":
		if e.complexity.Query.Nodes == nil {
			break
		}

		args, err := ec.field_Query_nodes_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Nodes(childComplexity, args["ids"].([]uuid.UUID)), true

	case "Query.posts":
		if e.complexity.Query.Posts == nil {
			break
		}

		args, err := ec.field_Query_posts_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Posts(childComplexity, args["after"].(*entgql.Cursor[uuid.UUID]), args["first"].(*int), args["before"].(*entgql.Cursor[uuid.UUID]), args["last"].(*int), args["orderBy"].(*ent.PostOrder), args["where"].(*ent.PostWhereInput)), true

	case "Query.profiles":
		if e.complexity.Query.Profiles == nil {
			break
		}

		args, err := ec.field_Query_profiles_args(context.TODO(), rawArgs)
		if err != nil {
			return 0, false
		}

		return e.complexity.Query.Profiles(childComplexity, args["after"].(*entgql.Cursor[uuid.UUID]), args["first"].(*int), args["before"].(*entgql.Cursor[uuid.UUID]), args["last"].(*int), args["orderBy"].(*ent.ProfileOrder), args["where"].(*ent.ProfileWhereInput)), true

	}
	return 0, false
}

func (e *executableSchema) Exec(ctx context.Context) graphql.ResponseHandler {
	rc := graphql.GetOperationContext(ctx)
	ec := executionContext{rc, e, 0, 0, make(chan graphql.DeferredResult)}
	inputUnmarshalMap := graphql.BuildUnmarshalerMap(
		ec.unmarshalInputCategoryOrder,
		ec.unmarshalInputCategoryWhereInput,
		ec.unmarshalInputCreateCategoryInput,
		ec.unmarshalInputCreatePostInput,
		ec.unmarshalInputCreateProfileInput,
		ec.unmarshalInputPostOrder,
		ec.unmarshalInputPostWhereInput,
		ec.unmarshalInputProfileOrder,
		ec.unmarshalInputProfileWhereInput,
		ec.unmarshalInputUpdateCategoryInput,
		ec.unmarshalInputUpdatePostInput,
		ec.unmarshalInputUpdateProfileInput,
	)
	first := true

	switch rc.Operation.Operation {
	case ast.Query:
		return func(ctx context.Context) *graphql.Response {
			var response graphql.Response
			var data graphql.Marshaler
			if first {
				first = false
				ctx = graphql.WithUnmarshalerMap(ctx, inputUnmarshalMap)
				data = ec._Query(ctx, rc.Operation.SelectionSet)
			} else {
				if atomic.LoadInt32(&ec.pendingDeferred) > 0 {
					result := <-ec.deferredResults
					atomic.AddInt32(&ec.pendingDeferred, -1)
					data = result.Result
					response.Path = result.Path
					response.Label = result.Label
					response.Errors = result.Errors
				} else {
					return nil
				}
			}
			var buf bytes.Buffer
			data.MarshalGQL(&buf)
			response.Data = buf.Bytes()
			if atomic.LoadInt32(&ec.deferred) > 0 {
				hasNext := atomic.LoadInt32(&ec.pendingDeferred) > 0
				response.HasNext = &hasNext
			}

			return &response
		}

	default:
		return graphql.OneShot(graphql.ErrorResponse(ctx, "unsupported GraphQL operation"))
	}
}

type executionContext struct {
	*graphql.OperationContext
	*executableSchema
	deferred        int32
	pendingDeferred int32
	deferredResults chan graphql.DeferredResult
}

func (ec *executionContext) processDeferredGroup(dg graphql.DeferredGroup) {
	atomic.AddInt32(&ec.pendingDeferred, 1)
	go func() {
		ctx := graphql.WithFreshResponseContext(dg.Context)
		dg.FieldSet.Dispatch(ctx)
		ds := graphql.DeferredResult{
			Path:   dg.Path,
			Label:  dg.Label,
			Result: dg.FieldSet,
			Errors: graphql.GetErrors(ctx),
		}
		// null fields should bubble up
		if dg.FieldSet.Invalids > 0 {
			ds.Result = graphql.Null
		}
		ec.deferredResults <- ds
	}()
}

func (ec *executionContext) introspectSchema() (*introspection.Schema, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapSchema(ec.Schema()), nil
}

func (ec *executionContext) introspectType(name string) (*introspection.Type, error) {
	if ec.DisableIntrospection {
		return nil, errors.New("introspection disabled")
	}
	return introspection.WrapTypeFromDef(ec.Schema(), ec.Schema().Types[name]), nil
}

var sources = []*ast.Source{
	{Name: "../../ent.graphql", Input: `directive @goField(forceResolver: Boolean, name: String, omittable: Boolean) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION
directive @goModel(model: String, models: [String!], forceGenerate: Boolean) on OBJECT | INPUT_OBJECT | SCALAR | ENUM | INTERFACE | UNION
type Category implements Node {
  id: ID!
  createdAt: Time!
  updatedAt: Time
  title: String!
  description: String
  posts(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: Cursor

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Ordering options for Posts returned from the connection.
    """
    orderBy: PostOrder

    """
    Filtering options for Posts returned from the connection.
    """
    where: PostWhereInput
  ): PostConnection!
}
"""
A connection to a list of items.
"""
type CategoryConnection {
  """
  A list of edges.
  """
  edges: [CategoryEdge]
  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
  """
  Identifies the total count of items in the connection.
  """
  totalCount: Int!
}
"""
An edge in a connection.
"""
type CategoryEdge {
  """
  The item at the end of the edge.
  """
  node: Category
  """
  A cursor for use in pagination.
  """
  cursor: Cursor!
}
"""
Ordering options for Category connections
"""
input CategoryOrder {
  """
  The ordering direction.
  """
  direction: OrderDirection! = ASC
  """
  The field by which to order Categories.
  """
  field: CategoryOrderField!
}
"""
Properties by which Category connections can be ordered.
"""
enum CategoryOrderField {
  CREATED_AT
  UPDATED_AT
  POSTS_COUNT
}
"""
CategoryWhereInput is used for filtering Category objects.
Input was generated by ent.
"""
input CategoryWhereInput {
  not: CategoryWhereInput
  and: [CategoryWhereInput!]
  or: [CategoryWhereInput!]
  """
  id field predicates
  """
  id: ID
  idNEQ: ID
  idIn: [ID!]
  idNotIn: [ID!]
  idGT: ID
  idGTE: ID
  idLT: ID
  idLTE: ID
  """
  created_at field predicates
  """
  createdAt: Time
  createdAtNEQ: Time
  createdAtIn: [Time!]
  createdAtNotIn: [Time!]
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time
  """
  updated_at field predicates
  """
  updatedAt: Time
  updatedAtNEQ: Time
  updatedAtIn: [Time!]
  updatedAtNotIn: [Time!]
  updatedAtGT: Time
  updatedAtGTE: Time
  updatedAtLT: Time
  updatedAtLTE: Time
  updatedAtIsNil: Boolean
  updatedAtNotNil: Boolean
  """
  title field predicates
  """
  title: String
  titleNEQ: String
  titleIn: [String!]
  titleNotIn: [String!]
  titleGT: String
  titleGTE: String
  titleLT: String
  titleLTE: String
  titleContains: String
  titleHasPrefix: String
  titleHasSuffix: String
  titleEqualFold: String
  titleContainsFold: String
  """
  description field predicates
  """
  description: String
  descriptionNEQ: String
  descriptionIn: [String!]
  descriptionNotIn: [String!]
  descriptionGT: String
  descriptionGTE: String
  descriptionLT: String
  descriptionLTE: String
  descriptionContains: String
  descriptionHasPrefix: String
  descriptionHasSuffix: String
  descriptionIsNil: Boolean
  descriptionNotNil: Boolean
  descriptionEqualFold: String
  descriptionContainsFold: String
  """
  posts edge predicates
  """
  hasPosts: Boolean
  hasPostsWith: [PostWhereInput!]
}
"""
CreateCategoryInput is used for create Category object.
Input was generated by ent.
"""
input CreateCategoryInput {
  createdAt: Time
  updatedAt: Time
  title: String!
  description: String
  postIDs: [ID!]
}
"""
CreatePostInput is used for create Post object.
Input was generated by ent.
"""
input CreatePostInput {
  createdAt: Time
  updatedAt: Time
  expires: Boolean
  expireTime: Time
  title: String!
  body: String!
  categoryID: ID
  profileID: ID
}
"""
CreateProfileInput is used for create Profile object.
Input was generated by ent.
"""
input CreateProfileInput {
  createdAt: Time
  updatedAt: Time
  name: String
  address: String
  phone: String
  postIDs: [ID!]
}
"""
Define a Relay Cursor type:
https://relay.dev/graphql/connections.htm#sec-Cursor
"""
scalar Cursor
"""
An object with an ID.
Follows the [Relay Global Object Identification Specification](https://relay.dev/graphql/objectidentification.htm)
"""
interface Node @goModel(model: "code.icod.de/dalu/ka/ent.Noder") {
  """
  The id of the object.
  """
  id: ID!
}
"""
Possible directions in which to order a list of items when provided an ` + "`" + `orderBy` + "`" + ` argument.
"""
enum OrderDirection {
  """
  Specifies an ascending order for a given ` + "`" + `orderBy` + "`" + ` argument.
  """
  ASC
  """
  Specifies a descending order for a given ` + "`" + `orderBy` + "`" + ` argument.
  """
  DESC
}
"""
Information about pagination in a connection.
https://relay.dev/graphql/connections.htm#sec-undefined.PageInfo
"""
type PageInfo {
  """
  When paginating forwards, are there more items?
  """
  hasNextPage: Boolean!
  """
  When paginating backwards, are there more items?
  """
  hasPreviousPage: Boolean!
  """
  When paginating backwards, the cursor to continue.
  """
  startCursor: Cursor
  """
  When paginating forwards, the cursor to continue.
  """
  endCursor: Cursor
}
type Post implements Node {
  id: ID!
  createdAt: Time!
  updatedAt: Time
  expires: Boolean!
  expireTime: Time
  title: String!
  body: String!
  category: Category
  profile: Profile
}
"""
A connection to a list of items.
"""
type PostConnection {
  """
  A list of edges.
  """
  edges: [PostEdge]
  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
  """
  Identifies the total count of items in the connection.
  """
  totalCount: Int!
}
"""
An edge in a connection.
"""
type PostEdge {
  """
  The item at the end of the edge.
  """
  node: Post
  """
  A cursor for use in pagination.
  """
  cursor: Cursor!
}
"""
Ordering options for Post connections
"""
input PostOrder {
  """
  The ordering direction.
  """
  direction: OrderDirection! = ASC
  """
  The field by which to order Posts.
  """
  field: PostOrderField!
}
"""
Properties by which Post connections can be ordered.
"""
enum PostOrderField {
  CREATED_AT
  UPDATED_AT
  EXPIRE_TIME
}
"""
PostWhereInput is used for filtering Post objects.
Input was generated by ent.
"""
input PostWhereInput {
  not: PostWhereInput
  and: [PostWhereInput!]
  or: [PostWhereInput!]
  """
  id field predicates
  """
  id: ID
  idNEQ: ID
  idIn: [ID!]
  idNotIn: [ID!]
  idGT: ID
  idGTE: ID
  idLT: ID
  idLTE: ID
  """
  created_at field predicates
  """
  createdAt: Time
  createdAtNEQ: Time
  createdAtIn: [Time!]
  createdAtNotIn: [Time!]
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time
  """
  updated_at field predicates
  """
  updatedAt: Time
  updatedAtNEQ: Time
  updatedAtIn: [Time!]
  updatedAtNotIn: [Time!]
  updatedAtGT: Time
  updatedAtGTE: Time
  updatedAtLT: Time
  updatedAtLTE: Time
  updatedAtIsNil: Boolean
  updatedAtNotNil: Boolean
  """
  expires field predicates
  """
  expires: Boolean
  expiresNEQ: Boolean
  """
  expire_time field predicates
  """
  expireTime: Time
  expireTimeNEQ: Time
  expireTimeIn: [Time!]
  expireTimeNotIn: [Time!]
  expireTimeGT: Time
  expireTimeGTE: Time
  expireTimeLT: Time
  expireTimeLTE: Time
  expireTimeIsNil: Boolean
  expireTimeNotNil: Boolean
  """
  title field predicates
  """
  title: String
  titleNEQ: String
  titleIn: [String!]
  titleNotIn: [String!]
  titleGT: String
  titleGTE: String
  titleLT: String
  titleLTE: String
  titleContains: String
  titleHasPrefix: String
  titleHasSuffix: String
  titleEqualFold: String
  titleContainsFold: String
  """
  body field predicates
  """
  body: String
  bodyNEQ: String
  bodyIn: [String!]
  bodyNotIn: [String!]
  bodyGT: String
  bodyGTE: String
  bodyLT: String
  bodyLTE: String
  bodyContains: String
  bodyHasPrefix: String
  bodyHasSuffix: String
  bodyEqualFold: String
  bodyContainsFold: String
  """
  category edge predicates
  """
  hasCategory: Boolean
  hasCategoryWith: [CategoryWhereInput!]
  """
  profile edge predicates
  """
  hasProfile: Boolean
  hasProfileWith: [ProfileWhereInput!]
}
type Profile implements Node {
  id: ID!
  createdAt: Time!
  updatedAt: Time
  name: String
  address: String
  phone: String
  posts(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: Cursor

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Ordering options for Posts returned from the connection.
    """
    orderBy: PostOrder

    """
    Filtering options for Posts returned from the connection.
    """
    where: PostWhereInput
  ): PostConnection!
}
"""
A connection to a list of items.
"""
type ProfileConnection {
  """
  A list of edges.
  """
  edges: [ProfileEdge]
  """
  Information to aid in pagination.
  """
  pageInfo: PageInfo!
  """
  Identifies the total count of items in the connection.
  """
  totalCount: Int!
}
"""
An edge in a connection.
"""
type ProfileEdge {
  """
  The item at the end of the edge.
  """
  node: Profile
  """
  A cursor for use in pagination.
  """
  cursor: Cursor!
}
"""
Ordering options for Profile connections
"""
input ProfileOrder {
  """
  The ordering direction.
  """
  direction: OrderDirection! = ASC
  """
  The field by which to order Profiles.
  """
  field: ProfileOrderField!
}
"""
Properties by which Profile connections can be ordered.
"""
enum ProfileOrderField {
  CREATED_AT
  UPDATED_AT
  POSTS_COUNT
}
"""
ProfileWhereInput is used for filtering Profile objects.
Input was generated by ent.
"""
input ProfileWhereInput {
  not: ProfileWhereInput
  and: [ProfileWhereInput!]
  or: [ProfileWhereInput!]
  """
  id field predicates
  """
  id: ID
  idNEQ: ID
  idIn: [ID!]
  idNotIn: [ID!]
  idGT: ID
  idGTE: ID
  idLT: ID
  idLTE: ID
  """
  created_at field predicates
  """
  createdAt: Time
  createdAtNEQ: Time
  createdAtIn: [Time!]
  createdAtNotIn: [Time!]
  createdAtGT: Time
  createdAtGTE: Time
  createdAtLT: Time
  createdAtLTE: Time
  """
  updated_at field predicates
  """
  updatedAt: Time
  updatedAtNEQ: Time
  updatedAtIn: [Time!]
  updatedAtNotIn: [Time!]
  updatedAtGT: Time
  updatedAtGTE: Time
  updatedAtLT: Time
  updatedAtLTE: Time
  updatedAtIsNil: Boolean
  updatedAtNotNil: Boolean
  """
  name field predicates
  """
  name: String
  nameNEQ: String
  nameIn: [String!]
  nameNotIn: [String!]
  nameGT: String
  nameGTE: String
  nameLT: String
  nameLTE: String
  nameContains: String
  nameHasPrefix: String
  nameHasSuffix: String
  nameIsNil: Boolean
  nameNotNil: Boolean
  nameEqualFold: String
  nameContainsFold: String
  """
  address field predicates
  """
  address: String
  addressNEQ: String
  addressIn: [String!]
  addressNotIn: [String!]
  addressGT: String
  addressGTE: String
  addressLT: String
  addressLTE: String
  addressContains: String
  addressHasPrefix: String
  addressHasSuffix: String
  addressIsNil: Boolean
  addressNotNil: Boolean
  addressEqualFold: String
  addressContainsFold: String
  """
  phone field predicates
  """
  phone: String
  phoneNEQ: String
  phoneIn: [String!]
  phoneNotIn: [String!]
  phoneGT: String
  phoneGTE: String
  phoneLT: String
  phoneLTE: String
  phoneContains: String
  phoneHasPrefix: String
  phoneHasSuffix: String
  phoneIsNil: Boolean
  phoneNotNil: Boolean
  phoneEqualFold: String
  phoneContainsFold: String
  """
  posts edge predicates
  """
  hasPosts: Boolean
  hasPostsWith: [PostWhereInput!]
}
type Query {
  """
  Fetches an object given its ID.
  """
  node(
    """
    ID of the object.
    """
    id: ID!
  ): Node
  """
  Lookup nodes by a list of IDs.
  """
  nodes(
    """
    The list of node IDs.
    """
    ids: [ID!]!
  ): [Node]!
  categories(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: Cursor

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Ordering options for Categories returned from the connection.
    """
    orderBy: CategoryOrder

    """
    Filtering options for Categories returned from the connection.
    """
    where: CategoryWhereInput
  ): CategoryConnection!
  posts(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: Cursor

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Ordering options for Posts returned from the connection.
    """
    orderBy: PostOrder

    """
    Filtering options for Posts returned from the connection.
    """
    where: PostWhereInput
  ): PostConnection!
  profiles(
    """
    Returns the elements in the list that come after the specified cursor.
    """
    after: Cursor

    """
    Returns the first _n_ elements from the list.
    """
    first: Int

    """
    Returns the elements in the list that come before the specified cursor.
    """
    before: Cursor

    """
    Returns the last _n_ elements from the list.
    """
    last: Int

    """
    Ordering options for Profiles returned from the connection.
    """
    orderBy: ProfileOrder

    """
    Filtering options for Profiles returned from the connection.
    """
    where: ProfileWhereInput
  ): ProfileConnection!
}
"""
The builtin Time type
"""
scalar Time
"""
UpdateCategoryInput is used for update Category object.
Input was generated by ent.
"""
input UpdateCategoryInput {
  updatedAt: Time
  clearUpdatedAt: Boolean
  title: String
  description: String
  clearDescription: Boolean
  addPostIDs: [ID!]
  removePostIDs: [ID!]
  clearPosts: Boolean
}
"""
UpdatePostInput is used for update Post object.
Input was generated by ent.
"""
input UpdatePostInput {
  updatedAt: Time
  clearUpdatedAt: Boolean
  expires: Boolean
  expireTime: Time
  clearExpireTime: Boolean
  title: String
  body: String
  categoryID: ID
  clearCategory: Boolean
  profileID: ID
  clearProfile: Boolean
}
"""
UpdateProfileInput is used for update Profile object.
Input was generated by ent.
"""
input UpdateProfileInput {
  updatedAt: Time
  clearUpdatedAt: Boolean
  name: String
  clearName: Boolean
  address: String
  clearAddress: Boolean
  phone: String
  clearPhone: Boolean
  addPostIDs: [ID!]
  removePostIDs: [ID!]
  clearPosts: Boolean
}
`, BuiltIn: false},
}
var parsedSchema = gqlparser.MustLoadSchema(sources...)