model

type AggregateResult struct {
	Count int `json:"count" db:"count"`
}

type Animal interface {
	GetID() int
	GetName() string
	GetType() string
}

type AnimalAvg struct {
	// Compute the avg for id
	ID float64 `json:"id" db:"id"`
}

type AnimalFilterInput struct {
	ID   *IntComparator    `json:"id,omitempty" db:"id"`
	Name *StringComparator `json:"name,omitempty" db:"name"`
	Type *StringComparator `json:"type,omitempty" db:"type"`
	Cat  *CatFilterInput   `json:"cat,omitempty" db:"cat"`
	Dog  *DogFilterInput   `json:"dog,omitempty" db:"dog"`
	// Logical AND of FilterInput
	And []*AnimalFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*AnimalFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *AnimalFilterInput `json:"NOT,omitempty" db:"not"`
}

type AnimalGroupBy string

type AnimalMax struct {
	// Compute the max for id
	ID int `json:"id" db:"id"`
	// Compute the max for name
	Name string `json:"name" db:"name"`
	// Compute the max for type
	Type string `json:"type" db:"type"`
}

type AnimalMin struct {
	// Compute the min for id
	ID int `json:"id" db:"id"`
	// Compute the min for name
	Name string `json:"name" db:"name"`
	// Compute the min for type
	Type string `json:"type" db:"type"`
}

type AnimalOrdering struct {
	// Order Animal by id
	ID *OrderingTypes `json:"id,omitempty" db:"id"`
	// Order Animal by name
	Name *OrderingTypes `json:"name,omitempty" db:"name"`
	// Order Animal by type
	Type *OrderingTypes `json:"type,omitempty" db:"type"`
}

type AnimalSum struct {
	// Compute the sum for id
	ID float64 `json:"id" db:"id"`
}

type AnimalsAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *AnimalMax `json:"max" db:"max"`
	// Min Aggregate
	Min *AnimalMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *AnimalAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *AnimalSum `json:"sum" db:"sum"`
}

type AnimalsAggregateAvg struct {
	// Compute the avg for count
	Count float64 `json:"count" db:"count"`
}

type AnimalsAggregateGroupBy string

type AnimalsAggregateMax struct {
	// Compute the max for count
	Count int `json:"count" db:"count"`
}

type AnimalsAggregateMin struct {
	// Compute the min for count
	Count int `json:"count" db:"count"`
}

type AnimalsAggregateOrdering struct {
	// Order AnimalsAggregate by group
	Group *OrderingTypes `json:"group,omitempty" db:"group"`
	// Order AnimalsAggregate by count
	Count *OrderingTypes `json:"count,omitempty" db:"count"`
}

type AnimalsAggregateSum struct {
	// Compute the sum for count
	Count float64 `json:"count" db:"count"`
}

type AnimalsAggregatesAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *AnimalsAggregateMax `json:"max" db:"max"`
	// Min Aggregate
	Min *AnimalsAggregateMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *AnimalsAggregateAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *AnimalsAggregateSum `json:"sum" db:"sum"`
}

type BooleanComparator struct {
	Eq     *bool `json:"eq,omitempty" db:"eq"`
	Neq    *bool `json:"neq,omitempty" db:"neq"`
	IsNull *bool `json:"isNull,omitempty" db:"is_null"`
}

type BooleanListComparator struct {
	Eq        []*bool `json:"eq,omitempty" db:"eq"`
	Neq       []*bool `json:"neq,omitempty" db:"neq"`
	Contains  []*bool `json:"contains,omitempty" db:"contains"`
	Contained []*bool `json:"contained,omitempty" db:"contained"`
	Overlap   []*bool `json:"overlap,omitempty" db:"overlap"`
	IsNull    *bool   `json:"isNull,omitempty" db:"is_null"`
}

type Cat struct {
	ID    int    `json:"id" db:"id"`
	Name  string `json:"name" db:"name"`
	Type  string `json:"type" db:"type"`
	Color string `json:"color" db:"color"`
}

type CatFilterInput struct {
	ID    *IntComparator    `json:"id,omitempty" db:"id"`
	Name  *StringComparator `json:"name,omitempty" db:"name"`
	Type  *StringComparator `json:"type,omitempty" db:"type"`
	Color *StringComparator `json:"color,omitempty" db:"color"`
	// Logical AND of FilterInput
	And []*CatFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*CatFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *CatFilterInput `json:"NOT,omitempty" db:"not"`
}

type CategoriesAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *CategoryMax `json:"max" db:"max"`
	// Min Aggregate
	Min *CategoryMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *CategoryAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *CategorySum `json:"sum" db:"sum"`
}

type CategoriesAggregateAvg struct {
	// Compute the avg for count
	Count float64 `json:"count" db:"count"`
}

type CategoriesAggregateGroupBy string

type CategoriesAggregateMax struct {
	// Compute the max for count
	Count int `json:"count" db:"count"`
}

type CategoriesAggregateMin struct {
	// Compute the min for count
	Count int `json:"count" db:"count"`
}

type CategoriesAggregateOrdering struct {
	// Order CategoriesAggregate by group
	Group *OrderingTypes `json:"group,omitempty" db:"group"`
	// Order CategoriesAggregate by count
	Count *OrderingTypes `json:"count,omitempty" db:"count"`
}

type CategoriesAggregateSum struct {
	// Compute the sum for count
	Count float64 `json:"count" db:"count"`
}

type CategoriesAggregatesAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *CategoriesAggregateMax `json:"max" db:"max"`
	// Min Aggregate
	Min *CategoriesAggregateMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *CategoriesAggregateAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *CategoriesAggregateSum `json:"sum" db:"sum"`
}

type Category struct {
	ID   int     `json:"id" db:"id"`
	Name *string `json:"name,omitempty" db:"name"`
}

type CategoryAvg struct {
	// Compute the avg for id
	ID float64 `json:"id" db:"id"`
}

type CategoryFilterInput struct {
	ID   *IntComparator    `json:"id,omitempty" db:"id"`
	Name *StringComparator `json:"name,omitempty" db:"name"`
	// Logical AND of FilterInput
	And []*CategoryFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*CategoryFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *CategoryFilterInput `json:"NOT,omitempty" db:"not"`
}

type CategoryGroupBy string

type CategoryMax struct {
	// Compute the max for id
	ID int `json:"id" db:"id"`
	// Compute the max for name
	Name string `json:"name" db:"name"`
}

type CategoryMin struct {
	// Compute the min for id
	ID int `json:"id" db:"id"`
	// Compute the min for name
	Name string `json:"name" db:"name"`
}

type CategoryOrdering struct {
	// Order Category by id
	ID *OrderingTypes `json:"id,omitempty" db:"id"`
	// Order Category by name
	Name *OrderingTypes `json:"name,omitempty" db:"name"`
}

type CategorySum struct {
	// Compute the sum for id
	ID float64 `json:"id" db:"id"`
}

type Dog struct {
	ID    int    `json:"id" db:"id"`
	Name  string `json:"name" db:"name"`
	Type  string `json:"type" db:"type"`
	Breed string `json:"breed" db:"breed"`
}

type DogFilterInput struct {
	ID    *IntComparator    `json:"id,omitempty" db:"id"`
	Name  *StringComparator `json:"name,omitempty" db:"name"`
	Type  *StringComparator `json:"type,omitempty" db:"type"`
	Breed *StringComparator `json:"breed,omitempty" db:"breed"`
	// Logical AND of FilterInput
	And []*DogFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*DogFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *DogFilterInput `json:"NOT,omitempty" db:"not"`
}

type FloatComparator struct {
	Eq     *float64 `json:"eq,omitempty" db:"eq"`
	Neq    *float64 `json:"neq,omitempty" db:"neq"`
	Gt     *float64 `json:"gt,omitempty" db:"gt"`
	Gte    *float64 `json:"gte,omitempty" db:"gte"`
	Lt     *float64 `json:"lt,omitempty" db:"lt"`
	Lte    *float64 `json:"lte,omitempty" db:"lte"`
	IsNull *bool    `json:"isNull,omitempty" db:"is_null"`
}

type FloatListComparator struct {
	Eq        []*float64 `json:"eq,omitempty" db:"eq"`
	Neq       []*float64 `json:"neq,omitempty" db:"neq"`
	Contains  []*float64 `json:"contains,omitempty" db:"contains"`
	Contained []*float64 `json:"contained,omitempty" db:"contained"`
	Overlap   []*float64 `json:"overlap,omitempty" db:"overlap"`
	IsNull    *bool      `json:"isNull,omitempty" db:"is_null"`
}

type IntComparator struct {
	Eq     *int  `json:"eq,omitempty" db:"eq"`
	Neq    *int  `json:"neq,omitempty" db:"neq"`
	Gt     *int  `json:"gt,omitempty" db:"gt"`
	Gte    *int  `json:"gte,omitempty" db:"gte"`
	Lt     *int  `json:"lt,omitempty" db:"lt"`
	Lte    *int  `json:"lte,omitempty" db:"lte"`
	IsNull *bool `json:"isNull,omitempty" db:"is_null"`
}

type IntListComparator struct {
	Eq        []*int `json:"eq,omitempty" db:"eq"`
	Neq       []*int `json:"neq,omitempty" db:"neq"`
	Contains  []*int `json:"contains,omitempty" db:"contains"`
	Contained []*int `json:"contained,omitempty" db:"contained"`
	Overlap   []*int `json:"overlap,omitempty" db:"overlap"`
	IsNull    *bool  `json:"isNull,omitempty" db:"is_null"`
}

type OrderingTypes string

type Post struct {
	ID         int         `json:"id" db:"id"`
	Name       *string     `json:"name,omitempty" db:"name"`
	Categories []*Category `json:"categories,omitempty" db:"categories"`
	UserID     *int        `json:"user_id,omitempty" db:"user_id"`
	User       *User       `json:"user,omitempty" db:"user"`
	// categories Aggregate
	CategoriesAggregate []*CategoriesAggregate `json:"_categoriesAggregate" db:"_categories_aggregate"`
	// user Aggregate
	UserAggregate []*UsersAggregate `json:"_userAggregate" db:"_user_aggregate"`
}

type PostAvg struct {
	// Compute the avg for id
	ID float64 `json:"id" db:"id"`
	// Compute the avg for user_id
	UserID float64 `json:"user_id" db:"user_id"`
}

type PostFilterInput struct {
	ID         *IntComparator       `json:"id,omitempty" db:"id"`
	Name       *StringComparator    `json:"name,omitempty" db:"name"`
	Categories *CategoryFilterInput `json:"categories,omitempty" db:"categories"`
	UserID     *IntComparator       `json:"user_id,omitempty" db:"user_id"`
	User       *UserFilterInput     `json:"user,omitempty" db:"user"`
	// Logical AND of FilterInput
	And []*PostFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*PostFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *PostFilterInput `json:"NOT,omitempty" db:"not"`
}

type PostGroupBy string

type PostMax struct {
	// Compute the max for id
	ID int `json:"id" db:"id"`
	// Compute the max for name
	Name string `json:"name" db:"name"`
	// Compute the max for user_id
	UserID int `json:"user_id" db:"user_id"`
}

type PostMin struct {
	// Compute the min for id
	ID int `json:"id" db:"id"`
	// Compute the min for name
	Name string `json:"name" db:"name"`
	// Compute the min for user_id
	UserID int `json:"user_id" db:"user_id"`
}

type PostOrdering struct {
	// Order Post by id
	ID *OrderingTypes `json:"id,omitempty" db:"id"`
	// Order Post by name
	Name *OrderingTypes `json:"name,omitempty" db:"name"`
	// Order Post by user_id
	UserID *OrderingTypes `json:"user_id,omitempty" db:"user_id"`
}

type PostSum struct {
	// Compute the sum for id
	ID float64 `json:"id" db:"id"`
	// Compute the sum for user_id
	UserID float64 `json:"user_id" db:"user_id"`
}

type PostsAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *PostMax `json:"max" db:"max"`
	// Min Aggregate
	Min *PostMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *PostAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *PostSum `json:"sum" db:"sum"`
}

type PostsAggregateAvg struct {
	// Compute the avg for count
	Count float64 `json:"count" db:"count"`
}

type PostsAggregateGroupBy string

type PostsAggregateMax struct {
	// Compute the max for count
	Count int `json:"count" db:"count"`
}

type PostsAggregateMin struct {
	// Compute the min for count
	Count int `json:"count" db:"count"`
}

type PostsAggregateOrdering struct {
	// Order PostsAggregate by group
	Group *OrderingTypes `json:"group,omitempty" db:"group"`
	// Order PostsAggregate by count
	Count *OrderingTypes `json:"count,omitempty" db:"count"`
}

type PostsAggregateSum struct {
	// Compute the sum for count
	Count float64 `json:"count" db:"count"`
}

type PostsAggregatesAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *PostsAggregateMax `json:"max" db:"max"`
	// Min Aggregate
	Min *PostsAggregateMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *PostsAggregateAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *PostsAggregateSum `json:"sum" db:"sum"`
}

type Query struct {
}

type RelationType string

type StringComparator struct {
	Eq          *string   `json:"eq,omitempty" db:"eq"`
	Neq         *string   `json:"neq,omitempty" db:"neq"`
	Contains    []*string `json:"contains,omitempty" db:"contains"`
	NotContains []*string `json:"notContains,omitempty" db:"not_contains"`
	Like        *string   `json:"like,omitempty" db:"like"`
	Ilike       *string   `json:"ilike,omitempty" db:"ilike"`
	Suffix      *string   `json:"suffix,omitempty" db:"suffix"`
	Prefix      *string   `json:"prefix,omitempty" db:"prefix"`
	IsNull      *bool     `json:"isNull,omitempty" db:"is_null"`
}

type StringListComparator struct {
	Eq          []*string `json:"eq,omitempty" db:"eq"`
	Neq         []*string `json:"neq,omitempty" db:"neq"`
	Contains    []*string `json:"contains,omitempty" db:"contains"`
	ContainedBy []*string `json:"containedBy,omitempty" db:"contained_by"`
	Overlap     []*string `json:"overlap,omitempty" db:"overlap"`
	IsNull      *bool     `json:"isNull,omitempty" db:"is_null"`
}

type User struct {
	ID    int     `json:"id" db:"id"`
	Name  string  `json:"name" db:"name"`
	Posts []*Post `json:"posts,omitempty" db:"posts"`
	// posts Aggregate
	PostsAggregate []*PostsAggregate `json:"_postsAggregate" db:"_posts_aggregate"`
}

type UserAvg struct {
	// Compute the avg for id
	ID float64 `json:"id" db:"id"`
}

type UserFilterInput struct {
	ID    *IntComparator    `json:"id,omitempty" db:"id"`
	Name  *StringComparator `json:"name,omitempty" db:"name"`
	Posts *PostFilterInput  `json:"posts,omitempty" db:"posts"`
	// Logical AND of FilterInput
	And []*UserFilterInput `json:"AND,omitempty" db:"and"`
	// Logical OR of FilterInput
	Or []*UserFilterInput `json:"OR,omitempty" db:"or"`
	// Logical NOT of FilterInput
	Not *UserFilterInput `json:"NOT,omitempty" db:"not"`
}

type UserGroupBy string

type UserMax struct {
	// Compute the max for id
	ID int `json:"id" db:"id"`
	// Compute the max for name
	Name string `json:"name" db:"name"`
}

type UserMin struct {
	// Compute the min for id
	ID int `json:"id" db:"id"`
	// Compute the min for name
	Name string `json:"name" db:"name"`
}

type UserOrdering struct {
	// Order User by id
	ID *OrderingTypes `json:"id,omitempty" db:"id"`
	// Order User by name
	Name *OrderingTypes `json:"name,omitempty" db:"name"`
}

type UserSum struct {
	// Compute the sum for id
	ID float64 `json:"id" db:"id"`
}

type UsersAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *UserMax `json:"max" db:"max"`
	// Min Aggregate
	Min *UserMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *UserAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *UserSum `json:"sum" db:"sum"`
}

type UsersAggregateAvg struct {
	// Compute the avg for count
	Count float64 `json:"count" db:"count"`
}

type UsersAggregateGroupBy string

type UsersAggregateMax struct {
	// Compute the max for count
	Count int `json:"count" db:"count"`
}

type UsersAggregateMin struct {
	// Compute the min for count
	Count int `json:"count" db:"count"`
}

type UsersAggregateOrdering struct {
	// Order UsersAggregate by group
	Group *OrderingTypes `json:"group,omitempty" db:"group"`
	// Order UsersAggregate by count
	Count *OrderingTypes `json:"count,omitempty" db:"count"`
}

type UsersAggregateSum struct {
	// Compute the sum for count
	Count float64 `json:"count" db:"count"`
}

type UsersAggregatesAggregate struct {
	// Group
	Group map[string]any `json:"group,omitempty" db:"group"`
	// Count results
	Count int `json:"count" db:"count"`
	// Max Aggregate
	Max *UsersAggregateMax `json:"max" db:"max"`
	// Min Aggregate
	Min *UsersAggregateMin `json:"min" db:"min"`
	// Avg Aggregate
	Avg *UsersAggregateAvg `json:"avg" db:"avg"`
	// Sum Aggregate
	Sum *UsersAggregateSum `json:"sum" db:"sum"`
}