ent

package

Go to main page

Versions in this module

v0

v0.5.0

Apr 11, 2024

Changes in this version

+ const TypeWorkspace

+ var CategoryOrderFieldStatus = &CategoryOrderField

+ var DefaultOrganizationOrder = &OrganizationOrder

+ var ErrEmptyOrganizationWhereInput = errors.New("ent: empty predicate OrganizationWhereInput")

+ var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction")

+ var TodoOrderFieldCategoryText = &TodoOrderField

type BillProductClient

+ func (c *BillProductClient) MapCreateBulk(slice any, setFunc func(*BillProductCreate, int)) *BillProductCreateBulk

type BillProductQuery

+ func (bpq *BillProductQuery) Modify(modifiers ...func(s *sql.Selector)) *BillProductSelect

type BillProductSelect

+ func (bps *BillProductSelect) Modify(modifiers ...func(s *sql.Selector)) *BillProductSelect

type BillProductUpdate

+ func (bpu *BillProductUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *BillProductUpdate

+ func (bpu *BillProductUpdate) SetNillableName(s *string) *BillProductUpdate

+ func (bpu *BillProductUpdate) SetNillableQuantity(u *uint64) *BillProductUpdate

+ func (bpu *BillProductUpdate) SetNillableSku(s *string) *BillProductUpdate

type BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetNillableName(s *string) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetNillableQuantity(u *uint64) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetNillableSku(s *string) *BillProductUpdateOne

type Category

+ Types *schematype.CategoryTypes

type CategoryClient

+ func (c *CategoryClient) MapCreateBulk(slice any, setFunc func(*CategoryCreate, int)) *CategoryCreateBulk

type CategoryCreate

+ func (cc *CategoryCreate) SetTypes(st *schematype.CategoryTypes) *CategoryCreate

type CategoryMutation

+ func (m *CategoryMutation) ClearTypes()

+ func (m *CategoryMutation) OldTypes(ctx context.Context) (v *schematype.CategoryTypes, err error)

+ func (m *CategoryMutation) ResetTypes()

+ func (m *CategoryMutation) SetTypes(st *schematype.CategoryTypes)

+ func (m *CategoryMutation) Types() (r *schematype.CategoryTypes, exists bool)

+ func (m *CategoryMutation) TypesCleared() bool

type CategoryQuery

+ func (cq *CategoryQuery) Modify(modifiers ...func(s *sql.Selector)) *CategorySelect

type CategorySelect

+ func (cs *CategorySelect) Modify(modifiers ...func(s *sql.Selector)) *CategorySelect

type CategoryUpdate

+ func (cu *CategoryUpdate) ClearTypes() *CategoryUpdate

+ func (cu *CategoryUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *CategoryUpdate

+ func (cu *CategoryUpdate) SetNillableStatus(c *category.Status) *CategoryUpdate

+ func (cu *CategoryUpdate) SetNillableText(s *string) *CategoryUpdate

+ func (cu *CategoryUpdate) SetTypes(st *schematype.CategoryTypes) *CategoryUpdate

type CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearTypes() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetNillableStatus(c *category.Status) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetNillableText(s *string) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetTypes(st *schematype.CategoryTypes) *CategoryUpdateOne

type Client

+ Workspace *WorkspaceClient

type CreateCategoryInput

+ Types *schematype.CategoryTypes

type CreateUserInput

+ RequiredMetadata map[string]interface{}

type FriendshipClient

+ func (c *FriendshipClient) MapCreateBulk(slice any, setFunc func(*FriendshipCreate, int)) *FriendshipCreateBulk

type FriendshipQuery

+ func (fq *FriendshipQuery) Modify(modifiers ...func(s *sql.Selector)) *FriendshipSelect

type FriendshipSelect

+ func (fs *FriendshipSelect) Modify(modifiers ...func(s *sql.Selector)) *FriendshipSelect

type FriendshipUpdate

+ func (fu *FriendshipUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetNillableFriendID(i *int) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetNillableUserID(i *int) *FriendshipUpdate

type FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetNillableFriendID(i *int) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetNillableUserID(i *int) *FriendshipUpdateOne

type Group

+ func (*Group) IsNamedNode()

type GroupClient

+ func (c *GroupClient) MapCreateBulk(slice any, setFunc func(*GroupCreate, int)) *GroupCreateBulk

type GroupQuery

+ func (gq *GroupQuery) Modify(modifiers ...func(s *sql.Selector)) *GroupSelect

type GroupSelect

+ func (gs *GroupSelect) Modify(modifiers ...func(s *sql.Selector)) *GroupSelect

type GroupUpdate

+ func (gu *GroupUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *GroupUpdate

type GroupUpdateOne

+ func (guo *GroupUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *GroupUpdateOne

type OneToManyClient

+ func (c *OneToManyClient) MapCreateBulk(slice any, setFunc func(*OneToManyCreate, int)) *OneToManyCreateBulk

type OneToManyQuery

+ func (otmq *OneToManyQuery) Modify(modifiers ...func(s *sql.Selector)) *OneToManySelect

type OneToManySelect

+ func (otms *OneToManySelect) Modify(modifiers ...func(s *sql.Selector)) *OneToManySelect

type OneToManyUpdate

+ func (otmu *OneToManyUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetNillableName(s *string) *OneToManyUpdate

type OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetNillableName(s *string) *OneToManyUpdateOne

+ type Organization = Workspace

+ func (w *Organization) ToEdge(order *OrganizationOrder) *OrganizationEdge

+ type OrganizationConnection struct

+ Edges []*OrganizationEdge

+ PageInfo PageInfo

+ TotalCount int

+ type OrganizationEdge struct

+ Cursor Cursor

+ Node *Organization

+ type OrganizationOrder struct

+ Direction OrderDirection

+ Field *OrganizationOrderField

+ type OrganizationOrderField struct

+ Value func(*Organization) (ent.Value, error)

+ type OrganizationPaginateOption func(*organizationPager) error

+ func WithOrganizationFilter(filter func(*WorkspaceQuery) (*WorkspaceQuery, error)) OrganizationPaginateOption

+ func WithOrganizationOrder(order *OrganizationOrder) OrganizationPaginateOption

+ type OrganizationWhereInput struct

+ And []*OrganizationWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Name *string

+ NameContains *string

+ NameContainsFold *string

+ NameEqualFold *string

+ NameGT *string

+ NameGTE *string

+ NameHasPrefix *string

+ NameHasSuffix *string

+ NameIn []string

+ NameLT *string

+ NameLTE *string

+ NameNEQ *string

+ NameNotIn []string

+ Not *OrganizationWhereInput

+ Or []*OrganizationWhereInput

+ Predicates []predicate.Workspace

+ func (i *OrganizationWhereInput) AddPredicates(predicates ...predicate.Workspace)

+ func (i *OrganizationWhereInput) Filter(q *WorkspaceQuery) (*WorkspaceQuery, error)

+ func (i *OrganizationWhereInput) P() (predicate.Workspace, error)

type ProjectClient

+ func (c *ProjectClient) MapCreateBulk(slice any, setFunc func(*ProjectCreate, int)) *ProjectCreateBulk

type ProjectQuery

+ func (pq *ProjectQuery) Modify(modifiers ...func(s *sql.Selector)) *ProjectSelect

type ProjectSelect

+ func (ps *ProjectSelect) Modify(modifiers ...func(s *sql.Selector)) *ProjectSelect

type ProjectUpdate

+ func (pu *ProjectUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ProjectUpdate

type ProjectUpdateOne

+ func (puo *ProjectUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *ProjectUpdateOne

type TodoClient

+ func (c *TodoClient) MapCreateBulk(slice any, setFunc func(*TodoCreate, int)) *TodoCreateBulk

type TodoQuery

+ func (tq *TodoQuery) Modify(modifiers ...func(s *sql.Selector)) *TodoSelect

type TodoSelect

+ func (ts *TodoSelect) Modify(modifiers ...func(s *sql.Selector)) *TodoSelect

type TodoUpdate

+ func (tu *TodoUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TodoUpdate

+ func (tu *TodoUpdate) SetNillableStatus(t *todo.Status) *TodoUpdate

+ func (tu *TodoUpdate) SetNillableText(s *string) *TodoUpdate

type TodoUpdateOne

+ func (tuo *TodoUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillableStatus(t *todo.Status) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillableText(s *string) *TodoUpdateOne

type Tx

+ Workspace *WorkspaceClient

type UpdateCategoryInput

+ ClearTypes bool

+ Types *schematype.CategoryTypes

type UpdateUserInput

+ RequiredMetadata map[string]interface{}

type User

+ RequiredMetadata map[string]interface{}

type UserClient

+ func (c *UserClient) MapCreateBulk(slice any, setFunc func(*UserCreate, int)) *UserCreateBulk

type UserCreate

+ func (uc *UserCreate) SetRequiredMetadata(m map[string]interface{}) *UserCreate

type UserMutation

+ func (m *UserMutation) OldRequiredMetadata(ctx context.Context) (v map[string]interface{}, err error)

+ func (m *UserMutation) RequiredMetadata() (r map[string]interface{}, exists bool)

+ func (m *UserMutation) ResetRequiredMetadata()

+ func (m *UserMutation) SetRequiredMetadata(value map[string]interface{})

type UserQuery

+ func (uq *UserQuery) Modify(modifiers ...func(s *sql.Selector)) *UserSelect

type UserSelect

+ func (us *UserSelect) Modify(modifiers ...func(s *sql.Selector)) *UserSelect

type UserUpdate

+ func (uu *UserUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdate

+ func (uu *UserUpdate) SetRequiredMetadata(m map[string]interface{}) *UserUpdate

type UserUpdateOne

+ func (uuo *UserUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetRequiredMetadata(m map[string]interface{}) *UserUpdateOne

type VerySecretClient

+ func (c *VerySecretClient) MapCreateBulk(slice any, setFunc func(*VerySecretCreate, int)) *VerySecretCreateBulk

type VerySecretQuery

+ func (vsq *VerySecretQuery) Modify(modifiers ...func(s *sql.Selector)) *VerySecretSelect

type VerySecretSelect

+ func (vss *VerySecretSelect) Modify(modifiers ...func(s *sql.Selector)) *VerySecretSelect

type VerySecretUpdate

+ func (vsu *VerySecretUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VerySecretUpdate

+ func (vsu *VerySecretUpdate) SetNillablePassword(s *string) *VerySecretUpdate

type VerySecretUpdateOne

+ func (vsuo *VerySecretUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *VerySecretUpdateOne

+ func (vsuo *VerySecretUpdateOne) SetNillablePassword(s *string) *VerySecretUpdateOne

+ type Workspace struct

+ ID int

+ Name string

+ func (*Workspace) IsNode()

+ func (w *Workspace) Node(ctx context.Context) (node *Node, err error)

+ func (w *Workspace) String() string

+ func (w *Workspace) Unwrap() *Workspace

+ func (w *Workspace) Update() *WorkspaceUpdateOne

+ func (w *Workspace) Value(name string) (ent.Value, error)

+ type WorkspaceClient struct

+ func NewWorkspaceClient(c config) *WorkspaceClient

+ func (c *WorkspaceClient) Create() *WorkspaceCreate

+ func (c *WorkspaceClient) CreateBulk(builders ...*WorkspaceCreate) *WorkspaceCreateBulk

+ func (c *WorkspaceClient) Delete() *WorkspaceDelete

+ func (c *WorkspaceClient) DeleteOne(w *Workspace) *WorkspaceDeleteOne

+ func (c *WorkspaceClient) DeleteOneID(id int) *WorkspaceDeleteOne

+ func (c *WorkspaceClient) Get(ctx context.Context, id int) (*Workspace, error)

+ func (c *WorkspaceClient) GetX(ctx context.Context, id int) *Workspace

+ func (c *WorkspaceClient) Hooks() []Hook

+ func (c *WorkspaceClient) Intercept(interceptors ...Interceptor)

+ func (c *WorkspaceClient) Interceptors() []Interceptor

+ func (c *WorkspaceClient) MapCreateBulk(slice any, setFunc func(*WorkspaceCreate, int)) *WorkspaceCreateBulk

+ func (c *WorkspaceClient) Query() *WorkspaceQuery

+ func (c *WorkspaceClient) Update() *WorkspaceUpdate

+ func (c *WorkspaceClient) UpdateOne(w *Workspace) *WorkspaceUpdateOne

+ func (c *WorkspaceClient) UpdateOneID(id int) *WorkspaceUpdateOne

+ func (c *WorkspaceClient) Use(hooks ...Hook)

+ type WorkspaceCreate struct

+ func (wc *WorkspaceCreate) Exec(ctx context.Context) error

+ func (wc *WorkspaceCreate) ExecX(ctx context.Context)

+ func (wc *WorkspaceCreate) Mutation() *WorkspaceMutation

+ func (wc *WorkspaceCreate) Save(ctx context.Context) (*Workspace, error)

+ func (wc *WorkspaceCreate) SaveX(ctx context.Context) *Workspace

+ func (wc *WorkspaceCreate) SetName(s string) *WorkspaceCreate

+ type WorkspaceCreateBulk struct

+ func (wcb *WorkspaceCreateBulk) Exec(ctx context.Context) error

+ func (wcb *WorkspaceCreateBulk) ExecX(ctx context.Context)

+ func (wcb *WorkspaceCreateBulk) Save(ctx context.Context) ([]*Workspace, error)

+ func (wcb *WorkspaceCreateBulk) SaveX(ctx context.Context) []*Workspace

+ type WorkspaceDelete struct

+ func (wd *WorkspaceDelete) Exec(ctx context.Context) (int, error)

+ func (wd *WorkspaceDelete) ExecX(ctx context.Context) int

+ func (wd *WorkspaceDelete) Where(ps ...predicate.Workspace) *WorkspaceDelete

+ type WorkspaceDeleteOne struct

+ func (wdo *WorkspaceDeleteOne) Exec(ctx context.Context) error

+ func (wdo *WorkspaceDeleteOne) ExecX(ctx context.Context)

+ func (wdo *WorkspaceDeleteOne) Where(ps ...predicate.Workspace) *WorkspaceDeleteOne

+ type WorkspaceGroupBy struct

+ func (s *WorkspaceGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *WorkspaceGroupBy) BoolX(ctx context.Context) bool

+ func (s *WorkspaceGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *WorkspaceGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *WorkspaceGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *WorkspaceGroupBy) Float64X(ctx context.Context) float64

+ func (s *WorkspaceGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *WorkspaceGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *WorkspaceGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *WorkspaceGroupBy) IntX(ctx context.Context) int

+ func (s *WorkspaceGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *WorkspaceGroupBy) IntsX(ctx context.Context) []int

+ func (s *WorkspaceGroupBy) ScanX(ctx context.Context, v any)

+ func (s *WorkspaceGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *WorkspaceGroupBy) StringX(ctx context.Context) string

+ func (s *WorkspaceGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *WorkspaceGroupBy) StringsX(ctx context.Context) []string

+ func (wgb *WorkspaceGroupBy) Aggregate(fns ...AggregateFunc) *WorkspaceGroupBy

+ func (wgb *WorkspaceGroupBy) Scan(ctx context.Context, v any) error

+ type WorkspaceMutation struct

+ func (m *WorkspaceMutation) AddField(name string, value ent.Value) error

+ func (m *WorkspaceMutation) AddedEdges() []string

+ func (m *WorkspaceMutation) AddedField(name string) (ent.Value, bool)

+ func (m *WorkspaceMutation) AddedFields() []string

+ func (m *WorkspaceMutation) AddedIDs(name string) []ent.Value

+ func (m *WorkspaceMutation) ClearEdge(name string) error

+ func (m *WorkspaceMutation) ClearField(name string) error

+ func (m *WorkspaceMutation) ClearedEdges() []string

+ func (m *WorkspaceMutation) ClearedFields() []string

+ func (m *WorkspaceMutation) EdgeCleared(name string) bool

+ func (m *WorkspaceMutation) Field(name string) (ent.Value, bool)

+ func (m *WorkspaceMutation) FieldCleared(name string) bool

+ func (m *WorkspaceMutation) Fields() []string

+ func (m *WorkspaceMutation) ID() (id int, exists bool)

+ func (m *WorkspaceMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *WorkspaceMutation) Name() (r string, exists bool)

+ func (m *WorkspaceMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *WorkspaceMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *WorkspaceMutation) Op() Op

+ func (m *WorkspaceMutation) RemovedEdges() []string

+ func (m *WorkspaceMutation) RemovedIDs(name string) []ent.Value

+ func (m *WorkspaceMutation) ResetEdge(name string) error

+ func (m *WorkspaceMutation) ResetField(name string) error

+ func (m *WorkspaceMutation) ResetName()

+ func (m *WorkspaceMutation) SetField(name string, value ent.Value) error

+ func (m *WorkspaceMutation) SetName(s string)

+ func (m *WorkspaceMutation) SetOp(op Op)

+ func (m *WorkspaceMutation) Type() string

+ func (m *WorkspaceMutation) Where(ps ...predicate.Workspace)

+ func (m *WorkspaceMutation) WhereP(ps ...func(*sql.Selector))

+ func (m WorkspaceMutation) Client() *Client

+ func (m WorkspaceMutation) Tx() (*Tx, error)

+ type WorkspaceQuery struct

+ func (w *WorkspaceQuery) CollectFields(ctx context.Context, satisfies ...string) (*WorkspaceQuery, error)

+ func (w *WorkspaceQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*OrganizationConnection, error)

+ func (wq *WorkspaceQuery) Aggregate(fns ...AggregateFunc) *WorkspaceSelect

+ func (wq *WorkspaceQuery) All(ctx context.Context) ([]*Workspace, error)

+ func (wq *WorkspaceQuery) AllX(ctx context.Context) []*Workspace

+ func (wq *WorkspaceQuery) Clone() *WorkspaceQuery

+ func (wq *WorkspaceQuery) Count(ctx context.Context) (int, error)

+ func (wq *WorkspaceQuery) CountX(ctx context.Context) int

+ func (wq *WorkspaceQuery) Exist(ctx context.Context) (bool, error)

+ func (wq *WorkspaceQuery) ExistX(ctx context.Context) bool

+ func (wq *WorkspaceQuery) First(ctx context.Context) (*Workspace, error)

+ func (wq *WorkspaceQuery) FirstID(ctx context.Context) (id int, err error)

+ func (wq *WorkspaceQuery) FirstIDX(ctx context.Context) int

+ func (wq *WorkspaceQuery) FirstX(ctx context.Context) *Workspace

+ func (wq *WorkspaceQuery) GroupBy(field string, fields ...string) *WorkspaceGroupBy

+ func (wq *WorkspaceQuery) IDs(ctx context.Context) (ids []int, err error)

+ func (wq *WorkspaceQuery) IDsX(ctx context.Context) []int

+ func (wq *WorkspaceQuery) Limit(limit int) *WorkspaceQuery

+ func (wq *WorkspaceQuery) Modify(modifiers ...func(s *sql.Selector)) *WorkspaceSelect

+ func (wq *WorkspaceQuery) Offset(offset int) *WorkspaceQuery

+ func (wq *WorkspaceQuery) Only(ctx context.Context) (*Workspace, error)

+ func (wq *WorkspaceQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (wq *WorkspaceQuery) OnlyIDX(ctx context.Context) int

+ func (wq *WorkspaceQuery) OnlyX(ctx context.Context) *Workspace

+ func (wq *WorkspaceQuery) Order(o ...workspace.OrderOption) *WorkspaceQuery

+ func (wq *WorkspaceQuery) Select(fields ...string) *WorkspaceSelect

+ func (wq *WorkspaceQuery) Unique(unique bool) *WorkspaceQuery

+ func (wq *WorkspaceQuery) Where(ps ...predicate.Workspace) *WorkspaceQuery

+ type WorkspaceSelect struct

+ func (s *WorkspaceSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *WorkspaceSelect) BoolX(ctx context.Context) bool

+ func (s *WorkspaceSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *WorkspaceSelect) BoolsX(ctx context.Context) []bool

+ func (s *WorkspaceSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *WorkspaceSelect) Float64X(ctx context.Context) float64

+ func (s *WorkspaceSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *WorkspaceSelect) Float64sX(ctx context.Context) []float64

+ func (s *WorkspaceSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *WorkspaceSelect) IntX(ctx context.Context) int

+ func (s *WorkspaceSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *WorkspaceSelect) IntsX(ctx context.Context) []int

+ func (s *WorkspaceSelect) ScanX(ctx context.Context, v any)

+ func (s *WorkspaceSelect) String(ctx context.Context) (_ string, err error)

+ func (s *WorkspaceSelect) StringX(ctx context.Context) string

+ func (s *WorkspaceSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *WorkspaceSelect) StringsX(ctx context.Context) []string

+ func (ws *WorkspaceSelect) Aggregate(fns ...AggregateFunc) *WorkspaceSelect

+ func (ws *WorkspaceSelect) Modify(modifiers ...func(s *sql.Selector)) *WorkspaceSelect

+ func (ws *WorkspaceSelect) Scan(ctx context.Context, v any) error

+ type WorkspaceUpdate struct

+ func (wu *WorkspaceUpdate) Exec(ctx context.Context) error

+ func (wu *WorkspaceUpdate) ExecX(ctx context.Context)

+ func (wu *WorkspaceUpdate) Modify(modifiers ...func(u *sql.UpdateBuilder)) *WorkspaceUpdate

+ func (wu *WorkspaceUpdate) Mutation() *WorkspaceMutation

+ func (wu *WorkspaceUpdate) Save(ctx context.Context) (int, error)

+ func (wu *WorkspaceUpdate) SaveX(ctx context.Context) int

+ func (wu *WorkspaceUpdate) SetName(s string) *WorkspaceUpdate

+ func (wu *WorkspaceUpdate) SetNillableName(s *string) *WorkspaceUpdate

+ func (wu *WorkspaceUpdate) Where(ps ...predicate.Workspace) *WorkspaceUpdate

+ type WorkspaceUpdateOne struct

+ func (wuo *WorkspaceUpdateOne) Exec(ctx context.Context) error

+ func (wuo *WorkspaceUpdateOne) ExecX(ctx context.Context)

+ func (wuo *WorkspaceUpdateOne) Modify(modifiers ...func(u *sql.UpdateBuilder)) *WorkspaceUpdateOne

+ func (wuo *WorkspaceUpdateOne) Mutation() *WorkspaceMutation

+ func (wuo *WorkspaceUpdateOne) Save(ctx context.Context) (*Workspace, error)

+ func (wuo *WorkspaceUpdateOne) SaveX(ctx context.Context) *Workspace

+ func (wuo *WorkspaceUpdateOne) Select(field string, fields ...string) *WorkspaceUpdateOne

+ func (wuo *WorkspaceUpdateOne) SetName(s string) *WorkspaceUpdateOne

+ func (wuo *WorkspaceUpdateOne) SetNillableName(s *string) *WorkspaceUpdateOne

+ func (wuo *WorkspaceUpdateOne) Where(ps ...predicate.Workspace) *WorkspaceUpdateOne

+ type Workspaces []*Workspace

v0.4.5

Apr 29, 2023

v0.4.4

Apr 23, 2023

v0.4.3

Apr 22, 2023

v0.4.2

Apr 20, 2023

Changes in this version

+ const TypeOneToMany

+ var DefaultOneToManyOrder = &OneToManyOrder

+ var ErrEmptyOneToManyWhereInput = errors.New("ent: empty predicate OneToManyWhereInput")

+ var OneToManyOrderFieldName = &OneToManyOrderField

type Client

+ OneToMany *OneToManyClient

+ type OneToManies []*OneToMany

+ type OneToMany struct

+ Edges OneToManyEdges

+ Field2 string

+ ID int

+ Name string

+ ParentID int

+ func (n *OneToMany) IsNode()

+ func (otm *OneToMany) Children(ctx context.Context) (result []*OneToMany, err error)

+ func (otm *OneToMany) NamedChildren(name string) ([]*OneToMany, error)

+ func (otm *OneToMany) Node(ctx context.Context) (node *Node, err error)

+ func (otm *OneToMany) Parent(ctx context.Context) (*OneToMany, error)

+ func (otm *OneToMany) QueryChildren() *OneToManyQuery

+ func (otm *OneToMany) QueryParent() *OneToManyQuery

+ func (otm *OneToMany) String() string

+ func (otm *OneToMany) ToEdge(order *OneToManyOrder) *OneToManyEdge

+ func (otm *OneToMany) Unwrap() *OneToMany

+ func (otm *OneToMany) Update() *OneToManyUpdateOne

+ func (otm *OneToMany) Value(name string) (ent.Value, error)

+ type OneToManyClient struct

+ func NewOneToManyClient(c config) *OneToManyClient

+ func (c *OneToManyClient) Create() *OneToManyCreate

+ func (c *OneToManyClient) CreateBulk(builders ...*OneToManyCreate) *OneToManyCreateBulk

+ func (c *OneToManyClient) Delete() *OneToManyDelete

+ func (c *OneToManyClient) DeleteOne(otm *OneToMany) *OneToManyDeleteOne

+ func (c *OneToManyClient) DeleteOneID(id int) *OneToManyDeleteOne

+ func (c *OneToManyClient) Get(ctx context.Context, id int) (*OneToMany, error)

+ func (c *OneToManyClient) GetX(ctx context.Context, id int) *OneToMany

+ func (c *OneToManyClient) Hooks() []Hook

+ func (c *OneToManyClient) Intercept(interceptors ...Interceptor)

+ func (c *OneToManyClient) Interceptors() []Interceptor

+ func (c *OneToManyClient) Query() *OneToManyQuery

+ func (c *OneToManyClient) QueryChildren(otm *OneToMany) *OneToManyQuery

+ func (c *OneToManyClient) QueryParent(otm *OneToMany) *OneToManyQuery

+ func (c *OneToManyClient) Update() *OneToManyUpdate

+ func (c *OneToManyClient) UpdateOne(otm *OneToMany) *OneToManyUpdateOne

+ func (c *OneToManyClient) UpdateOneID(id int) *OneToManyUpdateOne

+ func (c *OneToManyClient) Use(hooks ...Hook)

+ type OneToManyConnection struct

+ Edges []*OneToManyEdge

+ PageInfo PageInfo

+ TotalCount int

+ type OneToManyCreate struct

+ func (otmc *OneToManyCreate) AddChildIDs(ids ...int) *OneToManyCreate

+ func (otmc *OneToManyCreate) AddChildren(o ...*OneToMany) *OneToManyCreate

+ func (otmc *OneToManyCreate) Exec(ctx context.Context) error

+ func (otmc *OneToManyCreate) ExecX(ctx context.Context)

+ func (otmc *OneToManyCreate) Mutation() *OneToManyMutation

+ func (otmc *OneToManyCreate) Save(ctx context.Context) (*OneToMany, error)

+ func (otmc *OneToManyCreate) SaveX(ctx context.Context) *OneToMany

+ func (otmc *OneToManyCreate) SetField2(s string) *OneToManyCreate

+ func (otmc *OneToManyCreate) SetName(s string) *OneToManyCreate

+ func (otmc *OneToManyCreate) SetNillableField2(s *string) *OneToManyCreate

+ func (otmc *OneToManyCreate) SetNillableParentID(i *int) *OneToManyCreate

+ func (otmc *OneToManyCreate) SetParent(o *OneToMany) *OneToManyCreate

+ func (otmc *OneToManyCreate) SetParentID(i int) *OneToManyCreate

+ type OneToManyCreateBulk struct

+ func (otmcb *OneToManyCreateBulk) Exec(ctx context.Context) error

+ func (otmcb *OneToManyCreateBulk) ExecX(ctx context.Context)

+ func (otmcb *OneToManyCreateBulk) Save(ctx context.Context) ([]*OneToMany, error)

+ func (otmcb *OneToManyCreateBulk) SaveX(ctx context.Context) []*OneToMany

+ type OneToManyDelete struct

+ func (otmd *OneToManyDelete) Exec(ctx context.Context) (int, error)

+ func (otmd *OneToManyDelete) ExecX(ctx context.Context) int

+ func (otmd *OneToManyDelete) Where(ps ...predicate.OneToMany) *OneToManyDelete

+ type OneToManyDeleteOne struct

+ func (otmdo *OneToManyDeleteOne) Exec(ctx context.Context) error

+ func (otmdo *OneToManyDeleteOne) ExecX(ctx context.Context)

+ func (otmdo *OneToManyDeleteOne) Where(ps ...predicate.OneToMany) *OneToManyDeleteOne

+ type OneToManyEdge struct

+ Cursor Cursor

+ Node *OneToMany

+ type OneToManyEdges struct

+ Children []*OneToMany

+ Parent *OneToMany

+ func (e OneToManyEdges) ChildrenOrErr() ([]*OneToMany, error)

+ func (e OneToManyEdges) ParentOrErr() (*OneToMany, error)

+ type OneToManyGroupBy struct

+ func (otmgb *OneToManyGroupBy) Aggregate(fns ...AggregateFunc) *OneToManyGroupBy

+ func (otmgb *OneToManyGroupBy) Scan(ctx context.Context, v any) error

+ func (s *OneToManyGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *OneToManyGroupBy) BoolX(ctx context.Context) bool

+ func (s *OneToManyGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *OneToManyGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *OneToManyGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *OneToManyGroupBy) Float64X(ctx context.Context) float64

+ func (s *OneToManyGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *OneToManyGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *OneToManyGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *OneToManyGroupBy) IntX(ctx context.Context) int

+ func (s *OneToManyGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *OneToManyGroupBy) IntsX(ctx context.Context) []int

+ func (s *OneToManyGroupBy) ScanX(ctx context.Context, v any)

+ func (s *OneToManyGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *OneToManyGroupBy) StringX(ctx context.Context) string

+ func (s *OneToManyGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *OneToManyGroupBy) StringsX(ctx context.Context) []string

+ type OneToManyMutation struct

+ func (m *OneToManyMutation) AddChildIDs(ids ...int)

+ func (m *OneToManyMutation) AddField(name string, value ent.Value) error

+ func (m *OneToManyMutation) AddedEdges() []string

+ func (m *OneToManyMutation) AddedField(name string) (ent.Value, bool)

+ func (m *OneToManyMutation) AddedFields() []string

+ func (m *OneToManyMutation) AddedIDs(name string) []ent.Value

+ func (m *OneToManyMutation) ChildrenCleared() bool

+ func (m *OneToManyMutation) ChildrenIDs() (ids []int)

+ func (m *OneToManyMutation) ClearChildren()

+ func (m *OneToManyMutation) ClearEdge(name string) error

+ func (m *OneToManyMutation) ClearField(name string) error

+ func (m *OneToManyMutation) ClearField2()

+ func (m *OneToManyMutation) ClearParent()

+ func (m *OneToManyMutation) ClearParentID()

+ func (m *OneToManyMutation) ClearedEdges() []string

+ func (m *OneToManyMutation) ClearedFields() []string

+ func (m *OneToManyMutation) EdgeCleared(name string) bool

+ func (m *OneToManyMutation) Field(name string) (ent.Value, bool)

+ func (m *OneToManyMutation) Field2() (r string, exists bool)

+ func (m *OneToManyMutation) Field2Cleared() bool

+ func (m *OneToManyMutation) FieldCleared(name string) bool

+ func (m *OneToManyMutation) Fields() []string

+ func (m *OneToManyMutation) ID() (id int, exists bool)

+ func (m *OneToManyMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *OneToManyMutation) Name() (r string, exists bool)

+ func (m *OneToManyMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *OneToManyMutation) OldField2(ctx context.Context) (v string, err error)

+ func (m *OneToManyMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *OneToManyMutation) OldParentID(ctx context.Context) (v int, err error)

+ func (m *OneToManyMutation) Op() Op

+ func (m *OneToManyMutation) ParentCleared() bool

+ func (m *OneToManyMutation) ParentID() (r int, exists bool)

+ func (m *OneToManyMutation) ParentIDCleared() bool

+ func (m *OneToManyMutation) ParentIDs() (ids []int)

+ func (m *OneToManyMutation) RemoveChildIDs(ids ...int)

+ func (m *OneToManyMutation) RemovedChildrenIDs() (ids []int)

+ func (m *OneToManyMutation) RemovedEdges() []string

+ func (m *OneToManyMutation) RemovedIDs(name string) []ent.Value

+ func (m *OneToManyMutation) ResetChildren()

+ func (m *OneToManyMutation) ResetEdge(name string) error

+ func (m *OneToManyMutation) ResetField(name string) error

+ func (m *OneToManyMutation) ResetField2()

+ func (m *OneToManyMutation) ResetName()

+ func (m *OneToManyMutation) ResetParent()

+ func (m *OneToManyMutation) ResetParentID()

+ func (m *OneToManyMutation) SetField(name string, value ent.Value) error

+ func (m *OneToManyMutation) SetField2(s string)

+ func (m *OneToManyMutation) SetName(s string)

+ func (m *OneToManyMutation) SetOp(op Op)

+ func (m *OneToManyMutation) SetParentID(i int)

+ func (m *OneToManyMutation) Type() string

+ func (m *OneToManyMutation) Where(ps ...predicate.OneToMany)

+ func (m *OneToManyMutation) WhereP(ps ...func(*sql.Selector))

+ func (m OneToManyMutation) Client() *Client

+ func (m OneToManyMutation) Tx() (*Tx, error)

+ type OneToManyOrder struct

+ Direction OrderDirection

+ Field *OneToManyOrderField

+ type OneToManyOrderField struct

+ Value func(*OneToMany) (ent.Value, error)

+ func (f *OneToManyOrderField) UnmarshalGQL(v interface{}) error

+ func (f OneToManyOrderField) MarshalGQL(w io.Writer)

+ func (f OneToManyOrderField) String() string

+ type OneToManyPaginateOption func(*onetomanyPager) error

+ func WithOneToManyFilter(filter func(*OneToManyQuery) (*OneToManyQuery, error)) OneToManyPaginateOption

+ func WithOneToManyOrder(order *OneToManyOrder) OneToManyPaginateOption

+ type OneToManyQuery struct

+ func (otm *OneToManyQuery) CollectFields(ctx context.Context, satisfies ...string) (*OneToManyQuery, error)

+ func (otm *OneToManyQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*OneToManyConnection, error)

+ func (otmq *OneToManyQuery) Aggregate(fns ...AggregateFunc) *OneToManySelect

+ func (otmq *OneToManyQuery) All(ctx context.Context) ([]*OneToMany, error)

+ func (otmq *OneToManyQuery) AllX(ctx context.Context) []*OneToMany

+ func (otmq *OneToManyQuery) Clone() *OneToManyQuery

+ func (otmq *OneToManyQuery) Count(ctx context.Context) (int, error)

+ func (otmq *OneToManyQuery) CountX(ctx context.Context) int

+ func (otmq *OneToManyQuery) Exist(ctx context.Context) (bool, error)

+ func (otmq *OneToManyQuery) ExistX(ctx context.Context) bool

+ func (otmq *OneToManyQuery) First(ctx context.Context) (*OneToMany, error)

+ func (otmq *OneToManyQuery) FirstID(ctx context.Context) (id int, err error)

+ func (otmq *OneToManyQuery) FirstIDX(ctx context.Context) int

+ func (otmq *OneToManyQuery) FirstX(ctx context.Context) *OneToMany

+ func (otmq *OneToManyQuery) GroupBy(field string, fields ...string) *OneToManyGroupBy

+ func (otmq *OneToManyQuery) IDs(ctx context.Context) (ids []int, err error)

+ func (otmq *OneToManyQuery) IDsX(ctx context.Context) []int

+ func (otmq *OneToManyQuery) Limit(limit int) *OneToManyQuery

+ func (otmq *OneToManyQuery) Offset(offset int) *OneToManyQuery

+ func (otmq *OneToManyQuery) Only(ctx context.Context) (*OneToMany, error)

+ func (otmq *OneToManyQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (otmq *OneToManyQuery) OnlyIDX(ctx context.Context) int

+ func (otmq *OneToManyQuery) OnlyX(ctx context.Context) *OneToMany

+ func (otmq *OneToManyQuery) Order(o ...onetomany.OrderOption) *OneToManyQuery

+ func (otmq *OneToManyQuery) QueryChildren() *OneToManyQuery

+ func (otmq *OneToManyQuery) QueryParent() *OneToManyQuery

+ func (otmq *OneToManyQuery) Select(fields ...string) *OneToManySelect

+ func (otmq *OneToManyQuery) Unique(unique bool) *OneToManyQuery

+ func (otmq *OneToManyQuery) Where(ps ...predicate.OneToMany) *OneToManyQuery

+ func (otmq *OneToManyQuery) WithChildren(opts ...func(*OneToManyQuery)) *OneToManyQuery

+ func (otmq *OneToManyQuery) WithNamedChildren(name string, opts ...func(*OneToManyQuery)) *OneToManyQuery

+ func (otmq *OneToManyQuery) WithParent(opts ...func(*OneToManyQuery)) *OneToManyQuery

+ type OneToManySelect struct

+ func (otms *OneToManySelect) Aggregate(fns ...AggregateFunc) *OneToManySelect

+ func (otms *OneToManySelect) Scan(ctx context.Context, v any) error

+ func (s *OneToManySelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *OneToManySelect) BoolX(ctx context.Context) bool

+ func (s *OneToManySelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *OneToManySelect) BoolsX(ctx context.Context) []bool

+ func (s *OneToManySelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *OneToManySelect) Float64X(ctx context.Context) float64

+ func (s *OneToManySelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *OneToManySelect) Float64sX(ctx context.Context) []float64

+ func (s *OneToManySelect) Int(ctx context.Context) (_ int, err error)

+ func (s *OneToManySelect) IntX(ctx context.Context) int

+ func (s *OneToManySelect) Ints(ctx context.Context) ([]int, error)

+ func (s *OneToManySelect) IntsX(ctx context.Context) []int

+ func (s *OneToManySelect) ScanX(ctx context.Context, v any)

+ func (s *OneToManySelect) String(ctx context.Context) (_ string, err error)

+ func (s *OneToManySelect) StringX(ctx context.Context) string

+ func (s *OneToManySelect) Strings(ctx context.Context) ([]string, error)

+ func (s *OneToManySelect) StringsX(ctx context.Context) []string

+ type OneToManyUpdate struct

+ func (otmu *OneToManyUpdate) AddChildIDs(ids ...int) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) AddChildren(o ...*OneToMany) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) ClearChildren() *OneToManyUpdate

+ func (otmu *OneToManyUpdate) ClearField2() *OneToManyUpdate

+ func (otmu *OneToManyUpdate) ClearParent() *OneToManyUpdate

+ func (otmu *OneToManyUpdate) ClearParentID() *OneToManyUpdate

+ func (otmu *OneToManyUpdate) Exec(ctx context.Context) error

+ func (otmu *OneToManyUpdate) ExecX(ctx context.Context)

+ func (otmu *OneToManyUpdate) Mutation() *OneToManyMutation

+ func (otmu *OneToManyUpdate) RemoveChildIDs(ids ...int) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) RemoveChildren(o ...*OneToMany) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) Save(ctx context.Context) (int, error)

+ func (otmu *OneToManyUpdate) SaveX(ctx context.Context) int

+ func (otmu *OneToManyUpdate) SetField2(s string) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetName(s string) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetNillableField2(s *string) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetNillableParentID(i *int) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetParent(o *OneToMany) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) SetParentID(i int) *OneToManyUpdate

+ func (otmu *OneToManyUpdate) Where(ps ...predicate.OneToMany) *OneToManyUpdate

+ type OneToManyUpdateOne struct

+ func (otmuo *OneToManyUpdateOne) AddChildIDs(ids ...int) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) AddChildren(o ...*OneToMany) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) ClearChildren() *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) ClearField2() *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) ClearParent() *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) ClearParentID() *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) Exec(ctx context.Context) error

+ func (otmuo *OneToManyUpdateOne) ExecX(ctx context.Context)

+ func (otmuo *OneToManyUpdateOne) Mutation() *OneToManyMutation

+ func (otmuo *OneToManyUpdateOne) RemoveChildIDs(ids ...int) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) RemoveChildren(o ...*OneToMany) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) Save(ctx context.Context) (*OneToMany, error)

+ func (otmuo *OneToManyUpdateOne) SaveX(ctx context.Context) *OneToMany

+ func (otmuo *OneToManyUpdateOne) Select(field string, fields ...string) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetField2(s string) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetName(s string) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetNillableField2(s *string) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetNillableParentID(i *int) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetParent(o *OneToMany) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) SetParentID(i int) *OneToManyUpdateOne

+ func (otmuo *OneToManyUpdateOne) Where(ps ...predicate.OneToMany) *OneToManyUpdateOne

+ type OneToManyWhereInput struct

+ And []*OneToManyWhereInput

+ Field2 *string

+ Field2Contains *string

+ Field2ContainsFold *string

+ Field2EqualFold *string

+ Field2GT *string

+ Field2GTE *string

+ Field2HasPrefix *string

+ Field2HasSuffix *string

+ Field2In []string

+ Field2IsNil bool

+ Field2LT *string

+ Field2LTE *string

+ Field2NEQ *string

+ Field2NotIn []string

+ Field2NotNil bool

+ HasChildren *bool

+ HasChildrenWith []*OneToManyWhereInput

+ HasParent *bool

+ HasParentWith []*OneToManyWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Name *string

+ NameContains *string

+ NameContainsFold *string

+ NameEqualFold *string

+ NameGT *string

+ NameGTE *string

+ NameHasPrefix *string

+ NameHasSuffix *string

+ NameIn []string

+ NameLT *string

+ NameLTE *string

+ NameNEQ *string

+ NameNotIn []string

+ Not *OneToManyWhereInput

+ Or []*OneToManyWhereInput

+ Predicates []predicate.OneToMany

+ func (i *OneToManyWhereInput) AddPredicates(predicates ...predicate.OneToMany)

+ func (i *OneToManyWhereInput) Filter(q *OneToManyQuery) (*OneToManyQuery, error)

+ func (i *OneToManyWhereInput) P() (predicate.OneToMany, error)

type Tx

+ OneToMany *OneToManyClient

v0.4.1

Apr 16, 2023

Changes in this version

+ const TypeProject

+ var CategoryOrderFieldCategoryText = &TodoOrderField

+ var CategoryOrderFieldTodosCount = &CategoryOrderField

+ var DefaultProjectOrder = &ProjectOrder

+ var ErrEmptyProjectWhereInput = errors.New("ent: empty predicate ProjectWhereInput")

+ var TodoOrderFieldChildrenCount = &TodoOrderField

+ var TodoOrderFieldParentStatus = &TodoOrderField

+ var UserOrderFieldGroupsCount = &UserOrderField

type BillProductOrderField

+ Value func(*BillProduct) (ent.Value, error)

type CategoryOrderField

+ Value func(*Category) (ent.Value, error)

type Client

+ Project *ProjectClient

type FriendshipOrderField

+ Value func(*Friendship) (ent.Value, error)

type FriendshipUpdate

+ func (c *FriendshipUpdate) SetInput(i UpdateFriendshipInput) *FriendshipUpdate

type FriendshipUpdateOne

+ func (c *FriendshipUpdateOne) SetInput(i UpdateFriendshipInput) *FriendshipUpdateOne

type GroupOrderField

+ Value func(*Group) (ent.Value, error)

+ type Project struct

+ Edges ProjectEdges

+ ID int

+ func (n *Project) IsNode()

+ func (pr *Project) NamedTodos(name string) ([]*Todo, error)

+ func (pr *Project) Node(ctx context.Context) (node *Node, err error)

+ func (pr *Project) QueryTodos() *TodoQuery

+ func (pr *Project) String() string

+ func (pr *Project) ToEdge(order *ProjectOrder) *ProjectEdge

+ func (pr *Project) Todos(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*TodoConnection, error)

+ func (pr *Project) Unwrap() *Project

+ func (pr *Project) Update() *ProjectUpdateOne

+ func (pr *Project) Value(name string) (ent.Value, error)

+ type ProjectClient struct

+ func NewProjectClient(c config) *ProjectClient

+ func (c *ProjectClient) Create() *ProjectCreate

+ func (c *ProjectClient) CreateBulk(builders ...*ProjectCreate) *ProjectCreateBulk

+ func (c *ProjectClient) Delete() *ProjectDelete

+ func (c *ProjectClient) DeleteOne(pr *Project) *ProjectDeleteOne

+ func (c *ProjectClient) DeleteOneID(id int) *ProjectDeleteOne

+ func (c *ProjectClient) Get(ctx context.Context, id int) (*Project, error)

+ func (c *ProjectClient) GetX(ctx context.Context, id int) *Project

+ func (c *ProjectClient) Hooks() []Hook

+ func (c *ProjectClient) Intercept(interceptors ...Interceptor)

+ func (c *ProjectClient) Interceptors() []Interceptor

+ func (c *ProjectClient) Query() *ProjectQuery

+ func (c *ProjectClient) QueryTodos(pr *Project) *TodoQuery

+ func (c *ProjectClient) Update() *ProjectUpdate

+ func (c *ProjectClient) UpdateOne(pr *Project) *ProjectUpdateOne

+ func (c *ProjectClient) UpdateOneID(id int) *ProjectUpdateOne

+ func (c *ProjectClient) Use(hooks ...Hook)

+ type ProjectConnection struct

+ Edges []*ProjectEdge

+ PageInfo PageInfo

+ TotalCount int

+ type ProjectCreate struct

+ func (pc *ProjectCreate) AddTodoIDs(ids ...int) *ProjectCreate

+ func (pc *ProjectCreate) AddTodos(t ...*Todo) *ProjectCreate

+ func (pc *ProjectCreate) Exec(ctx context.Context) error

+ func (pc *ProjectCreate) ExecX(ctx context.Context)

+ func (pc *ProjectCreate) Mutation() *ProjectMutation

+ func (pc *ProjectCreate) Save(ctx context.Context) (*Project, error)

+ func (pc *ProjectCreate) SaveX(ctx context.Context) *Project

+ type ProjectCreateBulk struct

+ func (pcb *ProjectCreateBulk) Exec(ctx context.Context) error

+ func (pcb *ProjectCreateBulk) ExecX(ctx context.Context)

+ func (pcb *ProjectCreateBulk) Save(ctx context.Context) ([]*Project, error)

+ func (pcb *ProjectCreateBulk) SaveX(ctx context.Context) []*Project

+ type ProjectDelete struct

+ func (pd *ProjectDelete) Exec(ctx context.Context) (int, error)

+ func (pd *ProjectDelete) ExecX(ctx context.Context) int

+ func (pd *ProjectDelete) Where(ps ...predicate.Project) *ProjectDelete

+ type ProjectDeleteOne struct

+ func (pdo *ProjectDeleteOne) Exec(ctx context.Context) error

+ func (pdo *ProjectDeleteOne) ExecX(ctx context.Context)

+ func (pdo *ProjectDeleteOne) Where(ps ...predicate.Project) *ProjectDeleteOne

+ type ProjectEdge struct

+ Cursor Cursor

+ Node *Project

+ type ProjectEdges struct

+ Todos []*Todo

+ func (e ProjectEdges) TodosOrErr() ([]*Todo, error)

+ type ProjectGroupBy struct

+ func (pgb *ProjectGroupBy) Aggregate(fns ...AggregateFunc) *ProjectGroupBy

+ func (pgb *ProjectGroupBy) Scan(ctx context.Context, v any) error

+ func (s *ProjectGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *ProjectGroupBy) BoolX(ctx context.Context) bool

+ func (s *ProjectGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *ProjectGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *ProjectGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *ProjectGroupBy) Float64X(ctx context.Context) float64

+ func (s *ProjectGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *ProjectGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *ProjectGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *ProjectGroupBy) IntX(ctx context.Context) int

+ func (s *ProjectGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *ProjectGroupBy) IntsX(ctx context.Context) []int

+ func (s *ProjectGroupBy) ScanX(ctx context.Context, v any)

+ func (s *ProjectGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *ProjectGroupBy) StringX(ctx context.Context) string

+ func (s *ProjectGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *ProjectGroupBy) StringsX(ctx context.Context) []string

+ type ProjectMutation struct

+ func (m *ProjectMutation) AddField(name string, value ent.Value) error

+ func (m *ProjectMutation) AddTodoIDs(ids ...int)

+ func (m *ProjectMutation) AddedEdges() []string

+ func (m *ProjectMutation) AddedField(name string) (ent.Value, bool)

+ func (m *ProjectMutation) AddedFields() []string

+ func (m *ProjectMutation) AddedIDs(name string) []ent.Value

+ func (m *ProjectMutation) ClearEdge(name string) error

+ func (m *ProjectMutation) ClearField(name string) error

+ func (m *ProjectMutation) ClearTodos()

+ func (m *ProjectMutation) ClearedEdges() []string

+ func (m *ProjectMutation) ClearedFields() []string

+ func (m *ProjectMutation) EdgeCleared(name string) bool

+ func (m *ProjectMutation) Field(name string) (ent.Value, bool)

+ func (m *ProjectMutation) FieldCleared(name string) bool

+ func (m *ProjectMutation) Fields() []string

+ func (m *ProjectMutation) ID() (id int, exists bool)

+ func (m *ProjectMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *ProjectMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *ProjectMutation) Op() Op

+ func (m *ProjectMutation) RemoveTodoIDs(ids ...int)

+ func (m *ProjectMutation) RemovedEdges() []string

+ func (m *ProjectMutation) RemovedIDs(name string) []ent.Value

+ func (m *ProjectMutation) RemovedTodosIDs() (ids []int)

+ func (m *ProjectMutation) ResetEdge(name string) error

+ func (m *ProjectMutation) ResetField(name string) error

+ func (m *ProjectMutation) ResetTodos()

+ func (m *ProjectMutation) SetField(name string, value ent.Value) error

+ func (m *ProjectMutation) SetOp(op Op)

+ func (m *ProjectMutation) TodosCleared() bool

+ func (m *ProjectMutation) TodosIDs() (ids []int)

+ func (m *ProjectMutation) Type() string

+ func (m *ProjectMutation) Where(ps ...predicate.Project)

+ func (m *ProjectMutation) WhereP(ps ...func(*sql.Selector))

+ func (m ProjectMutation) Client() *Client

+ func (m ProjectMutation) Tx() (*Tx, error)

+ type ProjectOrder struct

+ Direction OrderDirection

+ Field *ProjectOrderField

+ type ProjectOrderField struct

+ Value func(*Project) (ent.Value, error)

+ type ProjectPaginateOption func(*projectPager) error

+ func WithProjectFilter(filter func(*ProjectQuery) (*ProjectQuery, error)) ProjectPaginateOption

+ func WithProjectOrder(order *ProjectOrder) ProjectPaginateOption

+ type ProjectQuery struct

+ func (pq *ProjectQuery) Aggregate(fns ...AggregateFunc) *ProjectSelect

+ func (pq *ProjectQuery) All(ctx context.Context) ([]*Project, error)

+ func (pq *ProjectQuery) AllX(ctx context.Context) []*Project

+ func (pq *ProjectQuery) Clone() *ProjectQuery

+ func (pq *ProjectQuery) Count(ctx context.Context) (int, error)

+ func (pq *ProjectQuery) CountX(ctx context.Context) int

+ func (pq *ProjectQuery) Exist(ctx context.Context) (bool, error)

+ func (pq *ProjectQuery) ExistX(ctx context.Context) bool

+ func (pq *ProjectQuery) First(ctx context.Context) (*Project, error)

+ func (pq *ProjectQuery) FirstID(ctx context.Context) (id int, err error)

+ func (pq *ProjectQuery) FirstIDX(ctx context.Context) int

+ func (pq *ProjectQuery) FirstX(ctx context.Context) *Project

+ func (pq *ProjectQuery) GroupBy(field string, fields ...string) *ProjectGroupBy

+ func (pq *ProjectQuery) IDs(ctx context.Context) (ids []int, err error)

+ func (pq *ProjectQuery) IDsX(ctx context.Context) []int

+ func (pq *ProjectQuery) Limit(limit int) *ProjectQuery

+ func (pq *ProjectQuery) Offset(offset int) *ProjectQuery

+ func (pq *ProjectQuery) Only(ctx context.Context) (*Project, error)

+ func (pq *ProjectQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (pq *ProjectQuery) OnlyIDX(ctx context.Context) int

+ func (pq *ProjectQuery) OnlyX(ctx context.Context) *Project

+ func (pq *ProjectQuery) Order(o ...project.OrderOption) *ProjectQuery

+ func (pq *ProjectQuery) QueryTodos() *TodoQuery

+ func (pq *ProjectQuery) Select(fields ...string) *ProjectSelect

+ func (pq *ProjectQuery) Unique(unique bool) *ProjectQuery

+ func (pq *ProjectQuery) Where(ps ...predicate.Project) *ProjectQuery

+ func (pq *ProjectQuery) WithNamedTodos(name string, opts ...func(*TodoQuery)) *ProjectQuery

+ func (pq *ProjectQuery) WithTodos(opts ...func(*TodoQuery)) *ProjectQuery

+ func (pr *ProjectQuery) CollectFields(ctx context.Context, satisfies ...string) (*ProjectQuery, error)

+ func (pr *ProjectQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*ProjectConnection, error)

+ type ProjectSelect struct

+ func (ps *ProjectSelect) Aggregate(fns ...AggregateFunc) *ProjectSelect

+ func (ps *ProjectSelect) Scan(ctx context.Context, v any) error

+ func (s *ProjectSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *ProjectSelect) BoolX(ctx context.Context) bool

+ func (s *ProjectSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *ProjectSelect) BoolsX(ctx context.Context) []bool

+ func (s *ProjectSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *ProjectSelect) Float64X(ctx context.Context) float64

+ func (s *ProjectSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *ProjectSelect) Float64sX(ctx context.Context) []float64

+ func (s *ProjectSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *ProjectSelect) IntX(ctx context.Context) int

+ func (s *ProjectSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *ProjectSelect) IntsX(ctx context.Context) []int

+ func (s *ProjectSelect) ScanX(ctx context.Context, v any)

+ func (s *ProjectSelect) String(ctx context.Context) (_ string, err error)

+ func (s *ProjectSelect) StringX(ctx context.Context) string

+ func (s *ProjectSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *ProjectSelect) StringsX(ctx context.Context) []string

+ type ProjectUpdate struct

+ func (pu *ProjectUpdate) AddTodoIDs(ids ...int) *ProjectUpdate

+ func (pu *ProjectUpdate) AddTodos(t ...*Todo) *ProjectUpdate

+ func (pu *ProjectUpdate) ClearTodos() *ProjectUpdate

+ func (pu *ProjectUpdate) Exec(ctx context.Context) error

+ func (pu *ProjectUpdate) ExecX(ctx context.Context)

+ func (pu *ProjectUpdate) Mutation() *ProjectMutation

+ func (pu *ProjectUpdate) RemoveTodoIDs(ids ...int) *ProjectUpdate

+ func (pu *ProjectUpdate) RemoveTodos(t ...*Todo) *ProjectUpdate

+ func (pu *ProjectUpdate) Save(ctx context.Context) (int, error)

+ func (pu *ProjectUpdate) SaveX(ctx context.Context) int

+ func (pu *ProjectUpdate) Where(ps ...predicate.Project) *ProjectUpdate

+ type ProjectUpdateOne struct

+ func (puo *ProjectUpdateOne) AddTodoIDs(ids ...int) *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) AddTodos(t ...*Todo) *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) ClearTodos() *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) Exec(ctx context.Context) error

+ func (puo *ProjectUpdateOne) ExecX(ctx context.Context)

+ func (puo *ProjectUpdateOne) Mutation() *ProjectMutation

+ func (puo *ProjectUpdateOne) RemoveTodoIDs(ids ...int) *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) RemoveTodos(t ...*Todo) *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) Save(ctx context.Context) (*Project, error)

+ func (puo *ProjectUpdateOne) SaveX(ctx context.Context) *Project

+ func (puo *ProjectUpdateOne) Select(field string, fields ...string) *ProjectUpdateOne

+ func (puo *ProjectUpdateOne) Where(ps ...predicate.Project) *ProjectUpdateOne

+ type ProjectWhereInput struct

+ And []*ProjectWhereInput

+ HasTodos *bool

+ HasTodosWith []*TodoWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Not *ProjectWhereInput

+ Or []*ProjectWhereInput

+ Predicates []predicate.Project

+ func (i *ProjectWhereInput) AddPredicates(predicates ...predicate.Project)

+ func (i *ProjectWhereInput) Filter(q *ProjectQuery) (*ProjectQuery, error)

+ func (i *ProjectWhereInput) P() (predicate.Project, error)

+ type Projects []*Project

type TodoOrderField

+ Value func(*Todo) (ent.Value, error)

type Tx

+ Project *ProjectClient

+ type UpdateFriendshipInput struct

+ CreatedAt *time.Time

+ FriendID *int

+ UserID *int

+ func (i *UpdateFriendshipInput) Mutate(m *FriendshipMutation)

type UserOrderField

+ Value func(*User) (ent.Value, error)

+ func (f *UserOrderField) UnmarshalGQL(v interface{}) error

+ func (f UserOrderField) MarshalGQL(w io.Writer)

+ func (f UserOrderField) String() string

v0.4.0

Apr 9, 2023

Changes in this version

+ var CategoryOrderFieldCount = &CategoryOrderField

+ var CategoryOrderFieldID = &CategoryOrderField

type BillProduct

+ func (bp *BillProduct) Value(name string) (ent.Value, error)

type BillProductDeleteOne

+ func (bpdo *BillProductDeleteOne) Where(ps ...predicate.BillProduct) *BillProductDeleteOne

type BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) Where(ps ...predicate.BillProduct) *BillProductUpdateOne

type Category

+ func (c *Category) NamedSubCategories(name string) ([]*Category, error)

+ func (c *Category) QuerySubCategories() *CategoryQuery

+ func (c *Category) SubCategories(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*CategoryConnection, error)

+ func (c *Category) Value(name string) (ent.Value, error)

type CategoryClient

+ func (c *CategoryClient) QuerySubCategories(ca *Category) *CategoryQuery

type CategoryCreate

+ func (cc *CategoryCreate) AddSubCategories(c ...*Category) *CategoryCreate

+ func (cc *CategoryCreate) AddSubCategoryIDs(ids ...int) *CategoryCreate

+ func (cc *CategoryCreate) SetID(i int) *CategoryCreate

type CategoryDeleteOne

+ func (cdo *CategoryDeleteOne) Where(ps ...predicate.Category) *CategoryDeleteOne

type CategoryEdges

+ SubCategories []*Category

+ func (e CategoryEdges) SubCategoriesOrErr() ([]*Category, error)

type CategoryMutation

+ func (m *CategoryMutation) AddSubCategoryIDs(ids ...int)

+ func (m *CategoryMutation) ClearSubCategories()

+ func (m *CategoryMutation) RemoveSubCategoryIDs(ids ...int)

+ func (m *CategoryMutation) RemovedSubCategoriesIDs() (ids []int)

+ func (m *CategoryMutation) ResetSubCategories()

+ func (m *CategoryMutation) SetID(id int)

+ func (m *CategoryMutation) SubCategoriesCleared() bool

+ func (m *CategoryMutation) SubCategoriesIDs() (ids []int)

type CategoryQuery

+ func (cq *CategoryQuery) QuerySubCategories() *CategoryQuery

+ func (cq *CategoryQuery) WithNamedSubCategories(name string, opts ...func(*CategoryQuery)) *CategoryQuery

+ func (cq *CategoryQuery) WithSubCategories(opts ...func(*CategoryQuery)) *CategoryQuery

type CategoryUpdate

+ func (cu *CategoryUpdate) AddSubCategories(c ...*Category) *CategoryUpdate

+ func (cu *CategoryUpdate) AddSubCategoryIDs(ids ...int) *CategoryUpdate

+ func (cu *CategoryUpdate) ClearSubCategories() *CategoryUpdate

+ func (cu *CategoryUpdate) RemoveSubCategories(c ...*Category) *CategoryUpdate

+ func (cu *CategoryUpdate) RemoveSubCategoryIDs(ids ...int) *CategoryUpdate

type CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AddSubCategories(c ...*Category) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AddSubCategoryIDs(ids ...int) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearSubCategories() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) RemoveSubCategories(c ...*Category) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) RemoveSubCategoryIDs(ids ...int) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) Where(ps ...predicate.Category) *CategoryUpdateOne

type CategoryWhereInput

+ HasSubCategories *bool

+ HasSubCategoriesWith []*CategoryWhereInput

type CreateCategoryInput

+ SubCategoryIDs []int

type CreateUserInput

+ Metadata map[string]interface{}

type Friendship

+ func (f *Friendship) Value(name string) (ent.Value, error)

type FriendshipDeleteOne

+ func (fdo *FriendshipDeleteOne) Where(ps ...predicate.Friendship) *FriendshipDeleteOne

type FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) Where(ps ...predicate.Friendship) *FriendshipUpdateOne

type Group

+ func (gr *Group) Value(name string) (ent.Value, error)

type GroupDeleteOne

+ func (gdo *GroupDeleteOne) Where(ps ...predicate.Group) *GroupDeleteOne

type GroupUpdateOne

+ func (guo *GroupUpdateOne) Where(ps ...predicate.Group) *GroupUpdateOne

type Todo

+ func (t *Todo) Value(name string) (ent.Value, error)

type TodoDeleteOne

+ func (tdo *TodoDeleteOne) Where(ps ...predicate.Todo) *TodoDeleteOne

type TodoUpdateOne

+ func (tuo *TodoUpdateOne) Where(ps ...predicate.Todo) *TodoUpdateOne

type UpdateCategoryInput

+ AddSubCategoryIDs []int

+ ClearSubCategories bool

+ RemoveSubCategoryIDs []int

type UpdateUserInput

+ ClearMetadata bool

+ Metadata map[string]interface{}

type User

+ Metadata map[string]interface{}

+ func (u *User) Value(name string) (ent.Value, error)

type UserCreate

+ func (uc *UserCreate) SetMetadata(m map[string]interface{}) *UserCreate

type UserDeleteOne

+ func (udo *UserDeleteOne) Where(ps ...predicate.User) *UserDeleteOne

type UserMutation

+ func (m *UserMutation) ClearMetadata()

+ func (m *UserMutation) Metadata() (r map[string]interface{}, exists bool)

+ func (m *UserMutation) MetadataCleared() bool

+ func (m *UserMutation) OldMetadata(ctx context.Context) (v map[string]interface{}, err error)

+ func (m *UserMutation) ResetMetadata()

+ func (m *UserMutation) SetMetadata(value map[string]interface{})

type UserUpdate

+ func (uu *UserUpdate) ClearMetadata() *UserUpdate

+ func (uu *UserUpdate) SetMetadata(m map[string]interface{}) *UserUpdate

type UserUpdateOne

+ func (uuo *UserUpdateOne) ClearMetadata() *UserUpdateOne

+ func (uuo *UserUpdateOne) SetMetadata(m map[string]interface{}) *UserUpdateOne

+ func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne

type VerySecret

+ func (vs *VerySecret) Value(name string) (ent.Value, error)

type VerySecretDeleteOne

+ func (vsdo *VerySecretDeleteOne) Where(ps ...predicate.VerySecret) *VerySecretDeleteOne

type VerySecretUpdateOne

+ func (vsuo *VerySecretUpdateOne) Where(ps ...predicate.VerySecret) *VerySecretUpdateOne

v0.3.5

Jan 27, 2023

Changes in this version

type BillProduct

+ func (n *BillProduct) IsNode()

type BillProductClient

+ func (c *BillProductClient) Intercept(interceptors ...Interceptor)

+ func (c *BillProductClient) Interceptors() []Interceptor

type BillProductMutation

+ func (m *BillProductMutation) SetOp(op Op)

+ func (m *BillProductMutation) WhereP(ps ...func(*sql.Selector))

type Category

+ func (n *Category) IsNode()

type CategoryClient

+ func (c *CategoryClient) Intercept(interceptors ...Interceptor)

+ func (c *CategoryClient) Interceptors() []Interceptor

type CategoryMutation

+ func (m *CategoryMutation) SetOp(op Op)

+ func (m *CategoryMutation) WhereP(ps ...func(*sql.Selector))

type Client

+ func (c *Client) Intercept(interceptors ...Interceptor)

+ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error)

type CreateUserInput

+ Username *uuid.UUID

type Friendship

+ func (n *Friendship) IsNode()

type FriendshipClient

+ func (c *FriendshipClient) Intercept(interceptors ...Interceptor)

+ func (c *FriendshipClient) Interceptors() []Interceptor

type FriendshipMutation

+ func (m *FriendshipMutation) SetOp(op Op)

+ func (m *FriendshipMutation) WhereP(ps ...func(*sql.Selector))

type Group

+ func (n *Group) IsNode()

type GroupClient

+ func (c *GroupClient) Intercept(interceptors ...Interceptor)

+ func (c *GroupClient) Interceptors() []Interceptor

type GroupMutation

+ func (m *GroupMutation) SetOp(op Op)

+ func (m *GroupMutation) WhereP(ps ...func(*sql.Selector))

+ type InterceptFunc = ent.InterceptFunc

+ type Interceptor = ent.Interceptor

type Noder

+ IsNode func()

+ type Querier = ent.Querier

+ type QuerierFunc = ent.QuerierFunc

+ type QueryContext = ent.QueryContext

type Todo

+ func (n *Todo) IsNode()

type TodoClient

+ func (c *TodoClient) Intercept(interceptors ...Interceptor)

+ func (c *TodoClient) Interceptors() []Interceptor

type TodoMutation

+ func (m *TodoMutation) SetOp(op Op)

+ func (m *TodoMutation) WhereP(ps ...func(*sql.Selector))

+ type TraverseFunc = ent.TraverseFunc

+ type Traverser = ent.Traverser

type UpdateCategoryInput

+ ClearTodos bool

type UpdateTodoInput

+ ClearChildren bool

type UpdateUserInput

+ ClearFriends bool

+ ClearGroups bool

+ Username *uuid.UUID

type User

+ Username uuid.UUID

+ func (n *User) IsNode()

type UserClient

+ func (c *UserClient) Intercept(interceptors ...Interceptor)

+ func (c *UserClient) Interceptors() []Interceptor

type UserCreate

+ func (uc *UserCreate) SetNillableUsername(u *uuid.UUID) *UserCreate

+ func (uc *UserCreate) SetUsername(u uuid.UUID) *UserCreate

type UserMutation

+ func (m *UserMutation) OldUsername(ctx context.Context) (v uuid.UUID, err error)

+ func (m *UserMutation) ResetUsername()

+ func (m *UserMutation) SetOp(op Op)

+ func (m *UserMutation) SetUsername(u uuid.UUID)

+ func (m *UserMutation) Username() (r uuid.UUID, exists bool)

+ func (m *UserMutation) WhereP(ps ...func(*sql.Selector))

type UserUpdate

+ func (uu *UserUpdate) SetNillableUsername(u *uuid.UUID) *UserUpdate

+ func (uu *UserUpdate) SetUsername(u uuid.UUID) *UserUpdate

type UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableUsername(u *uuid.UUID) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetUsername(u uuid.UUID) *UserUpdateOne

type UserWhereInput

+ Username *uuid.UUID

+ UsernameGT *uuid.UUID

+ UsernameGTE *uuid.UUID

+ UsernameIn []uuid.UUID

+ UsernameLT *uuid.UUID

+ UsernameLTE *uuid.UUID

+ UsernameNEQ *uuid.UUID

+ UsernameNotIn []uuid.UUID

type VerySecretClient

+ func (c *VerySecretClient) Intercept(interceptors ...Interceptor)

+ func (c *VerySecretClient) Interceptors() []Interceptor

type VerySecretMutation

+ func (m *VerySecretMutation) SetOp(op Op)

+ func (m *VerySecretMutation) WhereP(ps ...func(*sql.Selector))

v0.3.4

Nov 6, 2022

Changes in this version

+ const TypeBillProduct

+ var DefaultBillProductOrder = &BillProductOrder

+ var ErrEmptyBillProductWhereInput = errors.New("ent: empty predicate BillProductWhereInput")

+ type BillProduct struct

+ ID int

+ Name string

+ Quantity uint64

+ Sku string

+ func (bp *BillProduct) Node(ctx context.Context) (node *Node, err error)

+ func (bp *BillProduct) String() string

+ func (bp *BillProduct) ToEdge(order *BillProductOrder) *BillProductEdge

+ func (bp *BillProduct) Unwrap() *BillProduct

+ func (bp *BillProduct) Update() *BillProductUpdateOne

+ type BillProductClient struct

+ func NewBillProductClient(c config) *BillProductClient

+ func (c *BillProductClient) Create() *BillProductCreate

+ func (c *BillProductClient) CreateBulk(builders ...*BillProductCreate) *BillProductCreateBulk

+ func (c *BillProductClient) Delete() *BillProductDelete

+ func (c *BillProductClient) DeleteOne(bp *BillProduct) *BillProductDeleteOne

+ func (c *BillProductClient) DeleteOneID(id int) *BillProductDeleteOne

+ func (c *BillProductClient) Get(ctx context.Context, id int) (*BillProduct, error)

+ func (c *BillProductClient) GetX(ctx context.Context, id int) *BillProduct

+ func (c *BillProductClient) Hooks() []Hook

+ func (c *BillProductClient) Query() *BillProductQuery

+ func (c *BillProductClient) Update() *BillProductUpdate

+ func (c *BillProductClient) UpdateOne(bp *BillProduct) *BillProductUpdateOne

+ func (c *BillProductClient) UpdateOneID(id int) *BillProductUpdateOne

+ func (c *BillProductClient) Use(hooks ...Hook)

+ type BillProductConnection struct

+ Edges []*BillProductEdge

+ PageInfo PageInfo

+ TotalCount int

+ type BillProductCreate struct

+ func (bpc *BillProductCreate) Exec(ctx context.Context) error

+ func (bpc *BillProductCreate) ExecX(ctx context.Context)

+ func (bpc *BillProductCreate) Mutation() *BillProductMutation

+ func (bpc *BillProductCreate) Save(ctx context.Context) (*BillProduct, error)

+ func (bpc *BillProductCreate) SaveX(ctx context.Context) *BillProduct

+ func (bpc *BillProductCreate) SetName(s string) *BillProductCreate

+ func (bpc *BillProductCreate) SetQuantity(u uint64) *BillProductCreate

+ func (bpc *BillProductCreate) SetSku(s string) *BillProductCreate

+ type BillProductCreateBulk struct

+ func (bpcb *BillProductCreateBulk) Exec(ctx context.Context) error

+ func (bpcb *BillProductCreateBulk) ExecX(ctx context.Context)

+ func (bpcb *BillProductCreateBulk) Save(ctx context.Context) ([]*BillProduct, error)

+ func (bpcb *BillProductCreateBulk) SaveX(ctx context.Context) []*BillProduct

+ type BillProductDelete struct

+ func (bpd *BillProductDelete) Exec(ctx context.Context) (int, error)

+ func (bpd *BillProductDelete) ExecX(ctx context.Context) int

+ func (bpd *BillProductDelete) Where(ps ...predicate.BillProduct) *BillProductDelete

+ type BillProductDeleteOne struct

+ func (bpdo *BillProductDeleteOne) Exec(ctx context.Context) error

+ func (bpdo *BillProductDeleteOne) ExecX(ctx context.Context)

+ type BillProductEdge struct

+ Cursor Cursor

+ Node *BillProduct

+ type BillProductGroupBy struct

+ func (bpgb *BillProductGroupBy) Aggregate(fns ...AggregateFunc) *BillProductGroupBy

+ func (bpgb *BillProductGroupBy) Scan(ctx context.Context, v any) error

+ func (s *BillProductGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *BillProductGroupBy) BoolX(ctx context.Context) bool

+ func (s *BillProductGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *BillProductGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *BillProductGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *BillProductGroupBy) Float64X(ctx context.Context) float64

+ func (s *BillProductGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *BillProductGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *BillProductGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *BillProductGroupBy) IntX(ctx context.Context) int

+ func (s *BillProductGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *BillProductGroupBy) IntsX(ctx context.Context) []int

+ func (s *BillProductGroupBy) ScanX(ctx context.Context, v any)

+ func (s *BillProductGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *BillProductGroupBy) StringX(ctx context.Context) string

+ func (s *BillProductGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *BillProductGroupBy) StringsX(ctx context.Context) []string

+ type BillProductMutation struct

+ func (m *BillProductMutation) AddField(name string, value ent.Value) error

+ func (m *BillProductMutation) AddQuantity(u int64)

+ func (m *BillProductMutation) AddedEdges() []string

+ func (m *BillProductMutation) AddedField(name string) (ent.Value, bool)

+ func (m *BillProductMutation) AddedFields() []string

+ func (m *BillProductMutation) AddedIDs(name string) []ent.Value

+ func (m *BillProductMutation) AddedQuantity() (r int64, exists bool)

+ func (m *BillProductMutation) ClearEdge(name string) error

+ func (m *BillProductMutation) ClearField(name string) error

+ func (m *BillProductMutation) ClearedEdges() []string

+ func (m *BillProductMutation) ClearedFields() []string

+ func (m *BillProductMutation) EdgeCleared(name string) bool

+ func (m *BillProductMutation) Field(name string) (ent.Value, bool)

+ func (m *BillProductMutation) FieldCleared(name string) bool

+ func (m *BillProductMutation) Fields() []string

+ func (m *BillProductMutation) ID() (id int, exists bool)

+ func (m *BillProductMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *BillProductMutation) Name() (r string, exists bool)

+ func (m *BillProductMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *BillProductMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *BillProductMutation) OldQuantity(ctx context.Context) (v uint64, err error)

+ func (m *BillProductMutation) OldSku(ctx context.Context) (v string, err error)

+ func (m *BillProductMutation) Op() Op

+ func (m *BillProductMutation) Quantity() (r uint64, exists bool)

+ func (m *BillProductMutation) RemovedEdges() []string

+ func (m *BillProductMutation) RemovedIDs(name string) []ent.Value

+ func (m *BillProductMutation) ResetEdge(name string) error

+ func (m *BillProductMutation) ResetField(name string) error

+ func (m *BillProductMutation) ResetName()

+ func (m *BillProductMutation) ResetQuantity()

+ func (m *BillProductMutation) ResetSku()

+ func (m *BillProductMutation) SetField(name string, value ent.Value) error

+ func (m *BillProductMutation) SetName(s string)

+ func (m *BillProductMutation) SetQuantity(u uint64)

+ func (m *BillProductMutation) SetSku(s string)

+ func (m *BillProductMutation) Sku() (r string, exists bool)

+ func (m *BillProductMutation) Type() string

+ func (m *BillProductMutation) Where(ps ...predicate.BillProduct)

+ func (m BillProductMutation) Client() *Client

+ func (m BillProductMutation) Tx() (*Tx, error)

+ type BillProductOrder struct

+ Direction OrderDirection

+ Field *BillProductOrderField

+ type BillProductOrderField struct

+ type BillProductPaginateOption func(*billproductPager) error

+ func WithBillProductFilter(filter func(*BillProductQuery) (*BillProductQuery, error)) BillProductPaginateOption

+ func WithBillProductOrder(order *BillProductOrder) BillProductPaginateOption

+ type BillProductQuery struct

+ func (bp *BillProductQuery) CollectFields(ctx context.Context, satisfies ...string) (*BillProductQuery, error)

+ func (bp *BillProductQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*BillProductConnection, error)

+ func (bpq *BillProductQuery) Aggregate(fns ...AggregateFunc) *BillProductSelect

+ func (bpq *BillProductQuery) All(ctx context.Context) ([]*BillProduct, error)

+ func (bpq *BillProductQuery) AllX(ctx context.Context) []*BillProduct

+ func (bpq *BillProductQuery) Clone() *BillProductQuery

+ func (bpq *BillProductQuery) Count(ctx context.Context) (int, error)

+ func (bpq *BillProductQuery) CountX(ctx context.Context) int

+ func (bpq *BillProductQuery) Exist(ctx context.Context) (bool, error)

+ func (bpq *BillProductQuery) ExistX(ctx context.Context) bool

+ func (bpq *BillProductQuery) First(ctx context.Context) (*BillProduct, error)

+ func (bpq *BillProductQuery) FirstID(ctx context.Context) (id int, err error)

+ func (bpq *BillProductQuery) FirstIDX(ctx context.Context) int

+ func (bpq *BillProductQuery) FirstX(ctx context.Context) *BillProduct

+ func (bpq *BillProductQuery) GroupBy(field string, fields ...string) *BillProductGroupBy

+ func (bpq *BillProductQuery) IDs(ctx context.Context) ([]int, error)

+ func (bpq *BillProductQuery) IDsX(ctx context.Context) []int

+ func (bpq *BillProductQuery) Limit(limit int) *BillProductQuery

+ func (bpq *BillProductQuery) Offset(offset int) *BillProductQuery

+ func (bpq *BillProductQuery) Only(ctx context.Context) (*BillProduct, error)

+ func (bpq *BillProductQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (bpq *BillProductQuery) OnlyIDX(ctx context.Context) int

+ func (bpq *BillProductQuery) OnlyX(ctx context.Context) *BillProduct

+ func (bpq *BillProductQuery) Order(o ...OrderFunc) *BillProductQuery

+ func (bpq *BillProductQuery) Select(fields ...string) *BillProductSelect

+ func (bpq *BillProductQuery) Unique(unique bool) *BillProductQuery

+ func (bpq *BillProductQuery) Where(ps ...predicate.BillProduct) *BillProductQuery

+ type BillProductSelect struct

+ func (bps *BillProductSelect) Aggregate(fns ...AggregateFunc) *BillProductSelect

+ func (bps *BillProductSelect) Scan(ctx context.Context, v any) error

+ func (s *BillProductSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *BillProductSelect) BoolX(ctx context.Context) bool

+ func (s *BillProductSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *BillProductSelect) BoolsX(ctx context.Context) []bool

+ func (s *BillProductSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *BillProductSelect) Float64X(ctx context.Context) float64

+ func (s *BillProductSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *BillProductSelect) Float64sX(ctx context.Context) []float64

+ func (s *BillProductSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *BillProductSelect) IntX(ctx context.Context) int

+ func (s *BillProductSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *BillProductSelect) IntsX(ctx context.Context) []int

+ func (s *BillProductSelect) ScanX(ctx context.Context, v any)

+ func (s *BillProductSelect) String(ctx context.Context) (_ string, err error)

+ func (s *BillProductSelect) StringX(ctx context.Context) string

+ func (s *BillProductSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *BillProductSelect) StringsX(ctx context.Context) []string

+ type BillProductUpdate struct

+ func (bpu *BillProductUpdate) AddQuantity(u int64) *BillProductUpdate

+ func (bpu *BillProductUpdate) Exec(ctx context.Context) error

+ func (bpu *BillProductUpdate) ExecX(ctx context.Context)

+ func (bpu *BillProductUpdate) Mutation() *BillProductMutation

+ func (bpu *BillProductUpdate) Save(ctx context.Context) (int, error)

+ func (bpu *BillProductUpdate) SaveX(ctx context.Context) int

+ func (bpu *BillProductUpdate) SetName(s string) *BillProductUpdate

+ func (bpu *BillProductUpdate) SetQuantity(u uint64) *BillProductUpdate

+ func (bpu *BillProductUpdate) SetSku(s string) *BillProductUpdate

+ func (bpu *BillProductUpdate) Where(ps ...predicate.BillProduct) *BillProductUpdate

+ type BillProductUpdateOne struct

+ func (bpuo *BillProductUpdateOne) AddQuantity(u int64) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) Exec(ctx context.Context) error

+ func (bpuo *BillProductUpdateOne) ExecX(ctx context.Context)

+ func (bpuo *BillProductUpdateOne) Mutation() *BillProductMutation

+ func (bpuo *BillProductUpdateOne) Save(ctx context.Context) (*BillProduct, error)

+ func (bpuo *BillProductUpdateOne) SaveX(ctx context.Context) *BillProduct

+ func (bpuo *BillProductUpdateOne) Select(field string, fields ...string) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetName(s string) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetQuantity(u uint64) *BillProductUpdateOne

+ func (bpuo *BillProductUpdateOne) SetSku(s string) *BillProductUpdateOne

+ type BillProductWhereInput struct

+ And []*BillProductWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Name *string

+ NameContains *string

+ NameContainsFold *string

+ NameEqualFold *string

+ NameGT *string

+ NameGTE *string

+ NameHasPrefix *string

+ NameHasSuffix *string

+ NameIn []string

+ NameLT *string

+ NameLTE *string

+ NameNEQ *string

+ NameNotIn []string

+ Not *BillProductWhereInput

+ Or []*BillProductWhereInput

+ Predicates []predicate.BillProduct

+ Quantity *uint64

+ QuantityGT *uint64

+ QuantityGTE *uint64

+ QuantityIn []uint64

+ QuantityLT *uint64

+ QuantityLTE *uint64

+ QuantityNEQ *uint64

+ QuantityNotIn []uint64

+ Sku *string

+ SkuContains *string

+ SkuContainsFold *string

+ SkuEqualFold *string

+ SkuGT *string

+ SkuGTE *string

+ SkuHasPrefix *string

+ SkuHasSuffix *string

+ SkuIn []string

+ SkuLT *string

+ SkuLTE *string

+ SkuNEQ *string

+ SkuNotIn []string

+ func (i *BillProductWhereInput) AddPredicates(predicates ...predicate.BillProduct)

+ func (i *BillProductWhereInput) Filter(q *BillProductQuery) (*BillProductQuery, error)

+ func (i *BillProductWhereInput) P() (predicate.BillProduct, error)

+ type BillProducts []*BillProduct

type CategoryQuery

+ func (cq *CategoryQuery) Aggregate(fns ...AggregateFunc) *CategorySelect

type CategorySelect

+ func (cs *CategorySelect) Aggregate(fns ...AggregateFunc) *CategorySelect

type Client

+ BillProduct *BillProductClient

type CreateTodoInput

+ Init map[string]interface{}

type FriendshipQuery

+ func (fq *FriendshipQuery) Aggregate(fns ...AggregateFunc) *FriendshipSelect

type FriendshipSelect

+ func (fs *FriendshipSelect) Aggregate(fns ...AggregateFunc) *FriendshipSelect

type GroupQuery

+ func (gq *GroupQuery) Aggregate(fns ...AggregateFunc) *GroupSelect

type GroupSelect

+ func (gs *GroupSelect) Aggregate(fns ...AggregateFunc) *GroupSelect

type Todo

+ Custom []customstruct.Custom

+ Customp []*customstruct.Custom

+ Init map[string]interface{}

type TodoCreate

+ func (tc *TodoCreate) SetCustom(c []customstruct.Custom) *TodoCreate

+ func (tc *TodoCreate) SetCustomp(c []*customstruct.Custom) *TodoCreate

+ func (tc *TodoCreate) SetInit(m map[string]interface{}) *TodoCreate

type TodoMutation

+ func (m *TodoMutation) AppendCustom(c []customstruct.Custom)

+ func (m *TodoMutation) AppendCustomp(c []*customstruct.Custom)

+ func (m *TodoMutation) AppendedCustom() ([]customstruct.Custom, bool)

+ func (m *TodoMutation) AppendedCustomp() ([]*customstruct.Custom, bool)

+ func (m *TodoMutation) ClearCustom()

+ func (m *TodoMutation) ClearCustomp()

+ func (m *TodoMutation) ClearInit()

+ func (m *TodoMutation) Custom() (r []customstruct.Custom, exists bool)

+ func (m *TodoMutation) CustomCleared() bool

+ func (m *TodoMutation) Customp() (r []*customstruct.Custom, exists bool)

+ func (m *TodoMutation) CustompCleared() bool

+ func (m *TodoMutation) Init() (r map[string]interface{}, exists bool)

+ func (m *TodoMutation) InitCleared() bool

+ func (m *TodoMutation) OldCustom(ctx context.Context) (v []customstruct.Custom, err error)

+ func (m *TodoMutation) OldCustomp(ctx context.Context) (v []*customstruct.Custom, err error)

+ func (m *TodoMutation) OldInit(ctx context.Context) (v map[string]interface{}, err error)

+ func (m *TodoMutation) ResetCustom()

+ func (m *TodoMutation) ResetCustomp()

+ func (m *TodoMutation) ResetInit()

+ func (m *TodoMutation) SetCustom(c []customstruct.Custom)

+ func (m *TodoMutation) SetCustomp(c []*customstruct.Custom)

+ func (m *TodoMutation) SetInit(value map[string]interface{})

type TodoQuery

+ func (tq *TodoQuery) Aggregate(fns ...AggregateFunc) *TodoSelect

type TodoSelect

+ func (ts *TodoSelect) Aggregate(fns ...AggregateFunc) *TodoSelect

type TodoUpdate

+ func (tu *TodoUpdate) AppendCustom(c []customstruct.Custom) *TodoUpdate

+ func (tu *TodoUpdate) AppendCustomp(c []*customstruct.Custom) *TodoUpdate

+ func (tu *TodoUpdate) ClearCustom() *TodoUpdate

+ func (tu *TodoUpdate) ClearCustomp() *TodoUpdate

+ func (tu *TodoUpdate) ClearInit() *TodoUpdate

+ func (tu *TodoUpdate) SetCustom(c []customstruct.Custom) *TodoUpdate

+ func (tu *TodoUpdate) SetCustomp(c []*customstruct.Custom) *TodoUpdate

+ func (tu *TodoUpdate) SetInit(m map[string]interface{}) *TodoUpdate

type TodoUpdateOne

+ func (tuo *TodoUpdateOne) AppendCustom(c []customstruct.Custom) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) AppendCustomp(c []*customstruct.Custom) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearCustom() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearCustomp() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearInit() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetCustom(c []customstruct.Custom) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetCustomp(c []*customstruct.Custom) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetInit(m map[string]interface{}) *TodoUpdateOne

type Tx

+ BillProduct *BillProductClient

type UpdateTodoInput

+ ClearInit bool

+ Init map[string]interface{}

type UserQuery

+ func (uq *UserQuery) Aggregate(fns ...AggregateFunc) *UserSelect

type UserSelect

+ func (us *UserSelect) Aggregate(fns ...AggregateFunc) *UserSelect

type VerySecretQuery

+ func (vsq *VerySecretQuery) Aggregate(fns ...AggregateFunc) *VerySecretSelect

type VerySecretSelect

+ func (vss *VerySecretSelect) Aggregate(fns ...AggregateFunc) *VerySecretSelect

v0.3.3

Oct 4, 2022

Changes in this version

type CategoryCreate

+ func (c *CategoryCreate) SetInput(i CreateCategoryInput) *CategoryCreate

type CategoryMutation

+ func (m *CategoryMutation) AppendStrings(s []string)

+ func (m *CategoryMutation) AppendedStrings() ([]string, bool)

type CategoryUpdate

+ func (c *CategoryUpdate) SetInput(i UpdateCategoryInput) *CategoryUpdate

+ func (cu *CategoryUpdate) AppendStrings(s []string) *CategoryUpdate

type CategoryUpdateOne

+ func (c *CategoryUpdateOne) SetInput(i UpdateCategoryInput) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AppendStrings(s []string) *CategoryUpdateOne

+ type CreateCategoryInput struct

+ Config *schematype.CategoryConfig

+ Count *uint64

+ Duration *time.Duration

+ Status category.Status

+ Strings *[]string

+ Text string

+ TodoIDs []int

+ func (i *CreateCategoryInput) Mutate(m *CategoryMutation)

type CreateUserInput

+ Password *string

+ type UpdateCategoryInput struct

+ AddTodoIDs []int

+ AppendStrings *[]string

+ ClearConfig bool

+ ClearCount bool

+ ClearDuration bool

+ ClearStrings bool

+ Config *schematype.CategoryConfig

+ Count *uint64

+ Duration *time.Duration

+ RemoveTodoIDs []int

+ Status *category.Status

+ Strings *[]string

+ Text *string

+ func (i *UpdateCategoryInput) Mutate(m *CategoryMutation)

type UpdateUserInput

+ ClearPassword bool

+ Password *string

type User

+ Password string

type UserCreate

+ func (uc *UserCreate) SetNillablePassword(s *string) *UserCreate

+ func (uc *UserCreate) SetPassword(s string) *UserCreate

type UserMutation

+ func (m *UserMutation) ClearPassword()

+ func (m *UserMutation) OldPassword(ctx context.Context) (v string, err error)

+ func (m *UserMutation) Password() (r string, exists bool)

+ func (m *UserMutation) PasswordCleared() bool

+ func (m *UserMutation) ResetPassword()

+ func (m *UserMutation) SetPassword(s string)

type UserUpdate

+ func (uu *UserUpdate) ClearPassword() *UserUpdate

+ func (uu *UserUpdate) SetNillablePassword(s *string) *UserUpdate

+ func (uu *UserUpdate) SetPassword(s string) *UserUpdate

type UserUpdateOne

+ func (uuo *UserUpdateOne) ClearPassword() *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillablePassword(s *string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetPassword(s string) *UserUpdateOne

type UserWhereInput

+ Password *string

+ PasswordContains *string

+ PasswordContainsFold *string

+ PasswordEqualFold *string

+ PasswordGT *string

+ PasswordGTE *string

+ PasswordHasPrefix *string

+ PasswordHasSuffix *string

+ PasswordIn []string

+ PasswordIsNil bool

+ PasswordLT *string

+ PasswordLTE *string

+ PasswordNEQ *string

+ PasswordNotIn []string

+ PasswordNotNil bool

v0.3.2

Sep 2, 2022

Changes in this version

type TodoUpdate

+ func (c *TodoUpdate) SetInput(i UpdateTodoInput) *TodoUpdate

type TodoUpdateOne

+ func (c *TodoUpdateOne) SetInput(i UpdateTodoInput) *TodoUpdateOne

+ type UpdateTodoInput struct

+ AddChildIDs []int

+ ClearParent bool

+ ClearSecret bool

+ ParentID *int

+ Priority *int

+ RemoveChildIDs []int

+ SecretID *int

+ Status *todo.Status

+ Text *string

+ func (i *UpdateTodoInput) Mutate(m *TodoMutation)

v0.3.1

Aug 10, 2022

Changes in this version

type Category

+ func (c *Category) NamedTodos(name string) ([]*Todo, error)

type CategoryQuery

+ func (cq *CategoryQuery) WithNamedTodos(name string, opts ...func(*TodoQuery)) *CategoryQuery

type Group

+ func (gr *Group) NamedUsers(name string) ([]*User, error)

type GroupQuery

+ func (gq *GroupQuery) WithNamedUsers(name string, opts ...func(*UserQuery)) *GroupQuery

type Todo

+ func (t *Todo) NamedChildren(name string) ([]*Todo, error)

type TodoQuery

+ func (tq *TodoQuery) WithNamedChildren(name string, opts ...func(*TodoQuery)) *TodoQuery

type User

+ func (u *User) NamedFriends(name string) ([]*User, error)

+ func (u *User) NamedFriendships(name string) ([]*Friendship, error)

+ func (u *User) NamedGroups(name string) ([]*Group, error)

type UserQuery

+ func (uq *UserQuery) WithNamedFriends(name string, opts ...func(*UserQuery)) *UserQuery

+ func (uq *UserQuery) WithNamedFriendships(name string, opts ...func(*FriendshipQuery)) *UserQuery

+ func (uq *UserQuery) WithNamedGroups(name string, opts ...func(*GroupQuery)) *UserQuery

v0.3.0

Jun 29, 2022

Changes in this version

+ const TypeFriendship

+ const TypeGroup

+ const TypeUser

+ var DefaultFriendshipOrder = &FriendshipOrder

+ var DefaultGroupOrder = &GroupOrder

+ var DefaultUserOrder = &UserOrder

+ var ErrEmptyCategoryWhereInput = errors.New("ent: empty predicate CategoryWhereInput")

+ var ErrEmptyFriendshipWhereInput = errors.New("ent: empty predicate FriendshipWhereInput")

+ var ErrEmptyGroupWhereInput = errors.New("ent: empty predicate GroupWhereInput")

+ var ErrEmptyTodoWhereInput = errors.New("ent: empty predicate TodoWhereInput")

+ var ErrEmptyUserWhereInput = errors.New("ent: empty predicate UserWhereInput")

type Category

+ Strings []string

type CategoryCreate

+ func (cc *CategoryCreate) SetStrings(s []string) *CategoryCreate

type CategoryMutation

+ func (m *CategoryMutation) ClearStrings()

+ func (m *CategoryMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *CategoryMutation) OldStrings(ctx context.Context) (v []string, err error)

+ func (m *CategoryMutation) ResetStrings()

+ func (m *CategoryMutation) SetStrings(s []string)

+ func (m *CategoryMutation) Strings() (r []string, exists bool)

+ func (m *CategoryMutation) StringsCleared() bool

type CategoryUpdate

+ func (cu *CategoryUpdate) ClearStrings() *CategoryUpdate

+ func (cu *CategoryUpdate) SetStrings(s []string) *CategoryUpdate

type CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearStrings() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetStrings(s []string) *CategoryUpdateOne

type CategoryWhereInput

+ Predicates []predicate.Category

+ func (i *CategoryWhereInput) AddPredicates(predicates ...predicate.Category)

type Client

+ Friendship *FriendshipClient

+ Group *GroupClient

+ User *UserClient

+ type CreateTodoInput struct

+ CategoryID *int

+ ChildIDs []int

+ ParentID *int

+ Priority *int

+ SecretID *int

+ Status todo.Status

+ Text string

+ func (i *CreateTodoInput) Mutate(m *TodoMutation)

+ type CreateUserInput struct

+ FriendIDs []int

+ GroupIDs []int

+ Name *string

+ func (i *CreateUserInput) Mutate(m *UserMutation)

+ type Friendship struct

+ CreatedAt time.Time

+ Edges FriendshipEdges

+ FriendID int

+ ID int

+ UserID int

+ func (f *Friendship) Friend(ctx context.Context) (*User, error)

+ func (f *Friendship) Node(ctx context.Context) (node *Node, err error)

+ func (f *Friendship) QueryFriend() *UserQuery

+ func (f *Friendship) QueryUser() *UserQuery

+ func (f *Friendship) String() string

+ func (f *Friendship) ToEdge(order *FriendshipOrder) *FriendshipEdge

+ func (f *Friendship) Unwrap() *Friendship

+ func (f *Friendship) Update() *FriendshipUpdateOne

+ func (f *Friendship) User(ctx context.Context) (*User, error)

+ type FriendshipClient struct

+ func NewFriendshipClient(c config) *FriendshipClient

+ func (c *FriendshipClient) Create() *FriendshipCreate

+ func (c *FriendshipClient) CreateBulk(builders ...*FriendshipCreate) *FriendshipCreateBulk

+ func (c *FriendshipClient) Delete() *FriendshipDelete

+ func (c *FriendshipClient) DeleteOne(f *Friendship) *FriendshipDeleteOne

+ func (c *FriendshipClient) DeleteOneID(id int) *FriendshipDeleteOne

+ func (c *FriendshipClient) Get(ctx context.Context, id int) (*Friendship, error)

+ func (c *FriendshipClient) GetX(ctx context.Context, id int) *Friendship

+ func (c *FriendshipClient) Hooks() []Hook

+ func (c *FriendshipClient) Query() *FriendshipQuery

+ func (c *FriendshipClient) QueryFriend(f *Friendship) *UserQuery

+ func (c *FriendshipClient) QueryUser(f *Friendship) *UserQuery

+ func (c *FriendshipClient) Update() *FriendshipUpdate

+ func (c *FriendshipClient) UpdateOne(f *Friendship) *FriendshipUpdateOne

+ func (c *FriendshipClient) UpdateOneID(id int) *FriendshipUpdateOne

+ func (c *FriendshipClient) Use(hooks ...Hook)

+ type FriendshipConnection struct

+ Edges []*FriendshipEdge

+ PageInfo PageInfo

+ TotalCount int

+ type FriendshipCreate struct

+ func (fc *FriendshipCreate) Exec(ctx context.Context) error

+ func (fc *FriendshipCreate) ExecX(ctx context.Context)

+ func (fc *FriendshipCreate) Mutation() *FriendshipMutation

+ func (fc *FriendshipCreate) Save(ctx context.Context) (*Friendship, error)

+ func (fc *FriendshipCreate) SaveX(ctx context.Context) *Friendship

+ func (fc *FriendshipCreate) SetCreatedAt(t time.Time) *FriendshipCreate

+ func (fc *FriendshipCreate) SetFriend(u *User) *FriendshipCreate

+ func (fc *FriendshipCreate) SetFriendID(i int) *FriendshipCreate

+ func (fc *FriendshipCreate) SetNillableCreatedAt(t *time.Time) *FriendshipCreate

+ func (fc *FriendshipCreate) SetUser(u *User) *FriendshipCreate

+ func (fc *FriendshipCreate) SetUserID(i int) *FriendshipCreate

+ type FriendshipCreateBulk struct

+ func (fcb *FriendshipCreateBulk) Exec(ctx context.Context) error

+ func (fcb *FriendshipCreateBulk) ExecX(ctx context.Context)

+ func (fcb *FriendshipCreateBulk) Save(ctx context.Context) ([]*Friendship, error)

+ func (fcb *FriendshipCreateBulk) SaveX(ctx context.Context) []*Friendship

+ type FriendshipDelete struct

+ func (fd *FriendshipDelete) Exec(ctx context.Context) (int, error)

+ func (fd *FriendshipDelete) ExecX(ctx context.Context) int

+ func (fd *FriendshipDelete) Where(ps ...predicate.Friendship) *FriendshipDelete

+ type FriendshipDeleteOne struct

+ func (fdo *FriendshipDeleteOne) Exec(ctx context.Context) error

+ func (fdo *FriendshipDeleteOne) ExecX(ctx context.Context)

+ type FriendshipEdge struct

+ Cursor Cursor

+ Node *Friendship

+ type FriendshipEdges struct

+ Friend *User

+ User *User

+ func (e FriendshipEdges) FriendOrErr() (*User, error)

+ func (e FriendshipEdges) UserOrErr() (*User, error)

+ type FriendshipGroupBy struct

+ func (fgb *FriendshipGroupBy) Aggregate(fns ...AggregateFunc) *FriendshipGroupBy

+ func (fgb *FriendshipGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (s *FriendshipGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *FriendshipGroupBy) BoolX(ctx context.Context) bool

+ func (s *FriendshipGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *FriendshipGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *FriendshipGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *FriendshipGroupBy) Float64X(ctx context.Context) float64

+ func (s *FriendshipGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *FriendshipGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *FriendshipGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *FriendshipGroupBy) IntX(ctx context.Context) int

+ func (s *FriendshipGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *FriendshipGroupBy) IntsX(ctx context.Context) []int

+ func (s *FriendshipGroupBy) ScanX(ctx context.Context, v interface{})

+ func (s *FriendshipGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *FriendshipGroupBy) StringX(ctx context.Context) string

+ func (s *FriendshipGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *FriendshipGroupBy) StringsX(ctx context.Context) []string

+ type FriendshipMutation struct

+ func (m *FriendshipMutation) AddField(name string, value ent.Value) error

+ func (m *FriendshipMutation) AddedEdges() []string

+ func (m *FriendshipMutation) AddedField(name string) (ent.Value, bool)

+ func (m *FriendshipMutation) AddedFields() []string

+ func (m *FriendshipMutation) AddedIDs(name string) []ent.Value

+ func (m *FriendshipMutation) ClearEdge(name string) error

+ func (m *FriendshipMutation) ClearField(name string) error

+ func (m *FriendshipMutation) ClearFriend()

+ func (m *FriendshipMutation) ClearUser()

+ func (m *FriendshipMutation) ClearedEdges() []string

+ func (m *FriendshipMutation) ClearedFields() []string

+ func (m *FriendshipMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *FriendshipMutation) EdgeCleared(name string) bool

+ func (m *FriendshipMutation) Field(name string) (ent.Value, bool)

+ func (m *FriendshipMutation) FieldCleared(name string) bool

+ func (m *FriendshipMutation) Fields() []string

+ func (m *FriendshipMutation) FriendCleared() bool

+ func (m *FriendshipMutation) FriendID() (r int, exists bool)

+ func (m *FriendshipMutation) FriendIDs() (ids []int)

+ func (m *FriendshipMutation) ID() (id int, exists bool)

+ func (m *FriendshipMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *FriendshipMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *FriendshipMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *FriendshipMutation) OldFriendID(ctx context.Context) (v int, err error)

+ func (m *FriendshipMutation) OldUserID(ctx context.Context) (v int, err error)

+ func (m *FriendshipMutation) Op() Op

+ func (m *FriendshipMutation) RemovedEdges() []string

+ func (m *FriendshipMutation) RemovedIDs(name string) []ent.Value

+ func (m *FriendshipMutation) ResetCreatedAt()

+ func (m *FriendshipMutation) ResetEdge(name string) error

+ func (m *FriendshipMutation) ResetField(name string) error

+ func (m *FriendshipMutation) ResetFriend()

+ func (m *FriendshipMutation) ResetFriendID()

+ func (m *FriendshipMutation) ResetUser()

+ func (m *FriendshipMutation) ResetUserID()

+ func (m *FriendshipMutation) SetCreatedAt(t time.Time)

+ func (m *FriendshipMutation) SetField(name string, value ent.Value) error

+ func (m *FriendshipMutation) SetFriendID(i int)

+ func (m *FriendshipMutation) SetUserID(i int)

+ func (m *FriendshipMutation) Type() string

+ func (m *FriendshipMutation) UserCleared() bool

+ func (m *FriendshipMutation) UserID() (r int, exists bool)

+ func (m *FriendshipMutation) UserIDs() (ids []int)

+ func (m *FriendshipMutation) Where(ps ...predicate.Friendship)

+ func (m FriendshipMutation) Client() *Client

+ func (m FriendshipMutation) Tx() (*Tx, error)

+ type FriendshipOrder struct

+ Direction OrderDirection

+ Field *FriendshipOrderField

+ type FriendshipOrderField struct

+ type FriendshipPaginateOption func(*friendshipPager) error

+ func WithFriendshipFilter(filter func(*FriendshipQuery) (*FriendshipQuery, error)) FriendshipPaginateOption

+ func WithFriendshipOrder(order *FriendshipOrder) FriendshipPaginateOption

+ type FriendshipQuery struct

+ func (f *FriendshipQuery) CollectFields(ctx context.Context, satisfies ...string) (*FriendshipQuery, error)

+ func (f *FriendshipQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*FriendshipConnection, error)

+ func (fq *FriendshipQuery) All(ctx context.Context) ([]*Friendship, error)

+ func (fq *FriendshipQuery) AllX(ctx context.Context) []*Friendship

+ func (fq *FriendshipQuery) Clone() *FriendshipQuery

+ func (fq *FriendshipQuery) Count(ctx context.Context) (int, error)

+ func (fq *FriendshipQuery) CountX(ctx context.Context) int

+ func (fq *FriendshipQuery) Exist(ctx context.Context) (bool, error)

+ func (fq *FriendshipQuery) ExistX(ctx context.Context) bool

+ func (fq *FriendshipQuery) First(ctx context.Context) (*Friendship, error)

+ func (fq *FriendshipQuery) FirstID(ctx context.Context) (id int, err error)

+ func (fq *FriendshipQuery) FirstIDX(ctx context.Context) int

+ func (fq *FriendshipQuery) FirstX(ctx context.Context) *Friendship

+ func (fq *FriendshipQuery) GroupBy(field string, fields ...string) *FriendshipGroupBy

+ func (fq *FriendshipQuery) IDs(ctx context.Context) ([]int, error)

+ func (fq *FriendshipQuery) IDsX(ctx context.Context) []int

+ func (fq *FriendshipQuery) Limit(limit int) *FriendshipQuery

+ func (fq *FriendshipQuery) Offset(offset int) *FriendshipQuery

+ func (fq *FriendshipQuery) Only(ctx context.Context) (*Friendship, error)

+ func (fq *FriendshipQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (fq *FriendshipQuery) OnlyIDX(ctx context.Context) int

+ func (fq *FriendshipQuery) OnlyX(ctx context.Context) *Friendship

+ func (fq *FriendshipQuery) Order(o ...OrderFunc) *FriendshipQuery

+ func (fq *FriendshipQuery) QueryFriend() *UserQuery

+ func (fq *FriendshipQuery) QueryUser() *UserQuery

+ func (fq *FriendshipQuery) Select(fields ...string) *FriendshipSelect

+ func (fq *FriendshipQuery) Unique(unique bool) *FriendshipQuery

+ func (fq *FriendshipQuery) Where(ps ...predicate.Friendship) *FriendshipQuery

+ func (fq *FriendshipQuery) WithFriend(opts ...func(*UserQuery)) *FriendshipQuery

+ func (fq *FriendshipQuery) WithUser(opts ...func(*UserQuery)) *FriendshipQuery

+ type FriendshipSelect struct

+ func (fs *FriendshipSelect) Scan(ctx context.Context, v interface{}) error

+ func (s *FriendshipSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *FriendshipSelect) BoolX(ctx context.Context) bool

+ func (s *FriendshipSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *FriendshipSelect) BoolsX(ctx context.Context) []bool

+ func (s *FriendshipSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *FriendshipSelect) Float64X(ctx context.Context) float64

+ func (s *FriendshipSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *FriendshipSelect) Float64sX(ctx context.Context) []float64

+ func (s *FriendshipSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *FriendshipSelect) IntX(ctx context.Context) int

+ func (s *FriendshipSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *FriendshipSelect) IntsX(ctx context.Context) []int

+ func (s *FriendshipSelect) ScanX(ctx context.Context, v interface{})

+ func (s *FriendshipSelect) String(ctx context.Context) (_ string, err error)

+ func (s *FriendshipSelect) StringX(ctx context.Context) string

+ func (s *FriendshipSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *FriendshipSelect) StringsX(ctx context.Context) []string

+ type FriendshipUpdate struct

+ func (fu *FriendshipUpdate) ClearFriend() *FriendshipUpdate

+ func (fu *FriendshipUpdate) ClearUser() *FriendshipUpdate

+ func (fu *FriendshipUpdate) Exec(ctx context.Context) error

+ func (fu *FriendshipUpdate) ExecX(ctx context.Context)

+ func (fu *FriendshipUpdate) Mutation() *FriendshipMutation

+ func (fu *FriendshipUpdate) Save(ctx context.Context) (int, error)

+ func (fu *FriendshipUpdate) SaveX(ctx context.Context) int

+ func (fu *FriendshipUpdate) SetCreatedAt(t time.Time) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetFriend(u *User) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetFriendID(i int) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetNillableCreatedAt(t *time.Time) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetUser(u *User) *FriendshipUpdate

+ func (fu *FriendshipUpdate) SetUserID(i int) *FriendshipUpdate

+ func (fu *FriendshipUpdate) Where(ps ...predicate.Friendship) *FriendshipUpdate

+ type FriendshipUpdateOne struct

+ func (fuo *FriendshipUpdateOne) ClearFriend() *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) ClearUser() *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) Exec(ctx context.Context) error

+ func (fuo *FriendshipUpdateOne) ExecX(ctx context.Context)

+ func (fuo *FriendshipUpdateOne) Mutation() *FriendshipMutation

+ func (fuo *FriendshipUpdateOne) Save(ctx context.Context) (*Friendship, error)

+ func (fuo *FriendshipUpdateOne) SaveX(ctx context.Context) *Friendship

+ func (fuo *FriendshipUpdateOne) Select(field string, fields ...string) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetCreatedAt(t time.Time) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetFriend(u *User) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetFriendID(i int) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetNillableCreatedAt(t *time.Time) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetUser(u *User) *FriendshipUpdateOne

+ func (fuo *FriendshipUpdateOne) SetUserID(i int) *FriendshipUpdateOne

+ type FriendshipWhereInput struct

+ And []*FriendshipWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ FriendID *int

+ FriendIDIn []int

+ FriendIDNEQ *int

+ FriendIDNotIn []int

+ HasFriend *bool

+ HasFriendWith []*UserWhereInput

+ HasUser *bool

+ HasUserWith []*UserWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Not *FriendshipWhereInput

+ Or []*FriendshipWhereInput

+ Predicates []predicate.Friendship

+ UserID *int

+ UserIDIn []int

+ UserIDNEQ *int

+ UserIDNotIn []int

+ func (i *FriendshipWhereInput) AddPredicates(predicates ...predicate.Friendship)

+ func (i *FriendshipWhereInput) Filter(q *FriendshipQuery) (*FriendshipQuery, error)

+ func (i *FriendshipWhereInput) P() (predicate.Friendship, error)

+ type Friendships []*Friendship

+ type Group struct

+ Edges GroupEdges

+ ID int

+ Name string

+ func (gr *Group) Node(ctx context.Context) (node *Node, err error)

+ func (gr *Group) QueryUsers() *UserQuery

+ func (gr *Group) String() string

+ func (gr *Group) ToEdge(order *GroupOrder) *GroupEdge

+ func (gr *Group) Unwrap() *Group

+ func (gr *Group) Update() *GroupUpdateOne

+ func (gr *Group) Users(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*UserConnection, error)

+ type GroupClient struct

+ func NewGroupClient(c config) *GroupClient

+ func (c *GroupClient) Create() *GroupCreate

+ func (c *GroupClient) CreateBulk(builders ...*GroupCreate) *GroupCreateBulk

+ func (c *GroupClient) Delete() *GroupDelete

+ func (c *GroupClient) DeleteOne(gr *Group) *GroupDeleteOne

+ func (c *GroupClient) DeleteOneID(id int) *GroupDeleteOne

+ func (c *GroupClient) Get(ctx context.Context, id int) (*Group, error)

+ func (c *GroupClient) GetX(ctx context.Context, id int) *Group

+ func (c *GroupClient) Hooks() []Hook

+ func (c *GroupClient) Query() *GroupQuery

+ func (c *GroupClient) QueryUsers(gr *Group) *UserQuery

+ func (c *GroupClient) Update() *GroupUpdate

+ func (c *GroupClient) UpdateOne(gr *Group) *GroupUpdateOne

+ func (c *GroupClient) UpdateOneID(id int) *GroupUpdateOne

+ func (c *GroupClient) Use(hooks ...Hook)

+ type GroupConnection struct

+ Edges []*GroupEdge

+ PageInfo PageInfo

+ TotalCount int

+ type GroupCreate struct

+ func (gc *GroupCreate) AddUserIDs(ids ...int) *GroupCreate

+ func (gc *GroupCreate) AddUsers(u ...*User) *GroupCreate

+ func (gc *GroupCreate) Exec(ctx context.Context) error

+ func (gc *GroupCreate) ExecX(ctx context.Context)

+ func (gc *GroupCreate) Mutation() *GroupMutation

+ func (gc *GroupCreate) Save(ctx context.Context) (*Group, error)

+ func (gc *GroupCreate) SaveX(ctx context.Context) *Group

+ func (gc *GroupCreate) SetName(s string) *GroupCreate

+ func (gc *GroupCreate) SetNillableName(s *string) *GroupCreate

+ type GroupCreateBulk struct

+ func (gcb *GroupCreateBulk) Exec(ctx context.Context) error

+ func (gcb *GroupCreateBulk) ExecX(ctx context.Context)

+ func (gcb *GroupCreateBulk) Save(ctx context.Context) ([]*Group, error)

+ func (gcb *GroupCreateBulk) SaveX(ctx context.Context) []*Group

+ type GroupDelete struct

+ func (gd *GroupDelete) Exec(ctx context.Context) (int, error)

+ func (gd *GroupDelete) ExecX(ctx context.Context) int

+ func (gd *GroupDelete) Where(ps ...predicate.Group) *GroupDelete

+ type GroupDeleteOne struct

+ func (gdo *GroupDeleteOne) Exec(ctx context.Context) error

+ func (gdo *GroupDeleteOne) ExecX(ctx context.Context)

+ type GroupEdge struct

+ Cursor Cursor

+ Node *Group

+ type GroupEdges struct

+ Users []*User

+ func (e GroupEdges) UsersOrErr() ([]*User, error)

+ type GroupGroupBy struct

+ func (ggb *GroupGroupBy) Aggregate(fns ...AggregateFunc) *GroupGroupBy

+ func (ggb *GroupGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (s *GroupGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *GroupGroupBy) BoolX(ctx context.Context) bool

+ func (s *GroupGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *GroupGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *GroupGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *GroupGroupBy) Float64X(ctx context.Context) float64

+ func (s *GroupGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *GroupGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *GroupGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *GroupGroupBy) IntX(ctx context.Context) int

+ func (s *GroupGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *GroupGroupBy) IntsX(ctx context.Context) []int

+ func (s *GroupGroupBy) ScanX(ctx context.Context, v interface{})

+ func (s *GroupGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *GroupGroupBy) StringX(ctx context.Context) string

+ func (s *GroupGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *GroupGroupBy) StringsX(ctx context.Context) []string

+ type GroupMutation struct

+ func (m *GroupMutation) AddField(name string, value ent.Value) error

+ func (m *GroupMutation) AddUserIDs(ids ...int)

+ func (m *GroupMutation) AddedEdges() []string

+ func (m *GroupMutation) AddedField(name string) (ent.Value, bool)

+ func (m *GroupMutation) AddedFields() []string

+ func (m *GroupMutation) AddedIDs(name string) []ent.Value

+ func (m *GroupMutation) ClearEdge(name string) error

+ func (m *GroupMutation) ClearField(name string) error

+ func (m *GroupMutation) ClearUsers()

+ func (m *GroupMutation) ClearedEdges() []string

+ func (m *GroupMutation) ClearedFields() []string

+ func (m *GroupMutation) EdgeCleared(name string) bool

+ func (m *GroupMutation) Field(name string) (ent.Value, bool)

+ func (m *GroupMutation) FieldCleared(name string) bool

+ func (m *GroupMutation) Fields() []string

+ func (m *GroupMutation) ID() (id int, exists bool)

+ func (m *GroupMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *GroupMutation) Name() (r string, exists bool)

+ func (m *GroupMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *GroupMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *GroupMutation) Op() Op

+ func (m *GroupMutation) RemoveUserIDs(ids ...int)

+ func (m *GroupMutation) RemovedEdges() []string

+ func (m *GroupMutation) RemovedIDs(name string) []ent.Value

+ func (m *GroupMutation) RemovedUsersIDs() (ids []int)

+ func (m *GroupMutation) ResetEdge(name string) error

+ func (m *GroupMutation) ResetField(name string) error

+ func (m *GroupMutation) ResetName()

+ func (m *GroupMutation) ResetUsers()

+ func (m *GroupMutation) SetField(name string, value ent.Value) error

+ func (m *GroupMutation) SetName(s string)

+ func (m *GroupMutation) Type() string

+ func (m *GroupMutation) UsersCleared() bool

+ func (m *GroupMutation) UsersIDs() (ids []int)

+ func (m *GroupMutation) Where(ps ...predicate.Group)

+ func (m GroupMutation) Client() *Client

+ func (m GroupMutation) Tx() (*Tx, error)

+ type GroupOrder struct

+ Direction OrderDirection

+ Field *GroupOrderField

+ type GroupOrderField struct

+ type GroupPaginateOption func(*groupPager) error

+ func WithGroupFilter(filter func(*GroupQuery) (*GroupQuery, error)) GroupPaginateOption

+ func WithGroupOrder(order *GroupOrder) GroupPaginateOption

+ type GroupQuery struct

+ func (gq *GroupQuery) All(ctx context.Context) ([]*Group, error)

+ func (gq *GroupQuery) AllX(ctx context.Context) []*Group

+ func (gq *GroupQuery) Clone() *GroupQuery

+ func (gq *GroupQuery) Count(ctx context.Context) (int, error)

+ func (gq *GroupQuery) CountX(ctx context.Context) int

+ func (gq *GroupQuery) Exist(ctx context.Context) (bool, error)

+ func (gq *GroupQuery) ExistX(ctx context.Context) bool

+ func (gq *GroupQuery) First(ctx context.Context) (*Group, error)

+ func (gq *GroupQuery) FirstID(ctx context.Context) (id int, err error)

+ func (gq *GroupQuery) FirstIDX(ctx context.Context) int

+ func (gq *GroupQuery) FirstX(ctx context.Context) *Group

+ func (gq *GroupQuery) GroupBy(field string, fields ...string) *GroupGroupBy

+ func (gq *GroupQuery) IDs(ctx context.Context) ([]int, error)

+ func (gq *GroupQuery) IDsX(ctx context.Context) []int

+ func (gq *GroupQuery) Limit(limit int) *GroupQuery

+ func (gq *GroupQuery) Offset(offset int) *GroupQuery

+ func (gq *GroupQuery) Only(ctx context.Context) (*Group, error)

+ func (gq *GroupQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (gq *GroupQuery) OnlyIDX(ctx context.Context) int

+ func (gq *GroupQuery) OnlyX(ctx context.Context) *Group

+ func (gq *GroupQuery) Order(o ...OrderFunc) *GroupQuery

+ func (gq *GroupQuery) QueryUsers() *UserQuery

+ func (gq *GroupQuery) Select(fields ...string) *GroupSelect

+ func (gq *GroupQuery) Unique(unique bool) *GroupQuery

+ func (gq *GroupQuery) Where(ps ...predicate.Group) *GroupQuery

+ func (gq *GroupQuery) WithUsers(opts ...func(*UserQuery)) *GroupQuery

+ func (gr *GroupQuery) CollectFields(ctx context.Context, satisfies ...string) (*GroupQuery, error)

+ func (gr *GroupQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*GroupConnection, error)

+ type GroupSelect struct

+ func (gs *GroupSelect) Scan(ctx context.Context, v interface{}) error

+ func (s *GroupSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *GroupSelect) BoolX(ctx context.Context) bool

+ func (s *GroupSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *GroupSelect) BoolsX(ctx context.Context) []bool

+ func (s *GroupSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *GroupSelect) Float64X(ctx context.Context) float64

+ func (s *GroupSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *GroupSelect) Float64sX(ctx context.Context) []float64

+ func (s *GroupSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *GroupSelect) IntX(ctx context.Context) int

+ func (s *GroupSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *GroupSelect) IntsX(ctx context.Context) []int

+ func (s *GroupSelect) ScanX(ctx context.Context, v interface{})

+ func (s *GroupSelect) String(ctx context.Context) (_ string, err error)

+ func (s *GroupSelect) StringX(ctx context.Context) string

+ func (s *GroupSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *GroupSelect) StringsX(ctx context.Context) []string

+ type GroupUpdate struct

+ func (gu *GroupUpdate) AddUserIDs(ids ...int) *GroupUpdate

+ func (gu *GroupUpdate) AddUsers(u ...*User) *GroupUpdate

+ func (gu *GroupUpdate) ClearUsers() *GroupUpdate

+ func (gu *GroupUpdate) Exec(ctx context.Context) error

+ func (gu *GroupUpdate) ExecX(ctx context.Context)

+ func (gu *GroupUpdate) Mutation() *GroupMutation

+ func (gu *GroupUpdate) RemoveUserIDs(ids ...int) *GroupUpdate

+ func (gu *GroupUpdate) RemoveUsers(u ...*User) *GroupUpdate

+ func (gu *GroupUpdate) Save(ctx context.Context) (int, error)

+ func (gu *GroupUpdate) SaveX(ctx context.Context) int

+ func (gu *GroupUpdate) SetName(s string) *GroupUpdate

+ func (gu *GroupUpdate) SetNillableName(s *string) *GroupUpdate

+ func (gu *GroupUpdate) Where(ps ...predicate.Group) *GroupUpdate

+ type GroupUpdateOne struct

+ func (guo *GroupUpdateOne) AddUserIDs(ids ...int) *GroupUpdateOne

+ func (guo *GroupUpdateOne) AddUsers(u ...*User) *GroupUpdateOne

+ func (guo *GroupUpdateOne) ClearUsers() *GroupUpdateOne

+ func (guo *GroupUpdateOne) Exec(ctx context.Context) error

+ func (guo *GroupUpdateOne) ExecX(ctx context.Context)

+ func (guo *GroupUpdateOne) Mutation() *GroupMutation

+ func (guo *GroupUpdateOne) RemoveUserIDs(ids ...int) *GroupUpdateOne

+ func (guo *GroupUpdateOne) RemoveUsers(u ...*User) *GroupUpdateOne

+ func (guo *GroupUpdateOne) Save(ctx context.Context) (*Group, error)

+ func (guo *GroupUpdateOne) SaveX(ctx context.Context) *Group

+ func (guo *GroupUpdateOne) Select(field string, fields ...string) *GroupUpdateOne

+ func (guo *GroupUpdateOne) SetName(s string) *GroupUpdateOne

+ func (guo *GroupUpdateOne) SetNillableName(s *string) *GroupUpdateOne

+ type GroupWhereInput struct

+ And []*GroupWhereInput

+ HasUsers *bool

+ HasUsersWith []*UserWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Name *string

+ NameContains *string

+ NameContainsFold *string

+ NameEqualFold *string

+ NameGT *string

+ NameGTE *string

+ NameHasPrefix *string

+ NameHasSuffix *string

+ NameIn []string

+ NameLT *string

+ NameLTE *string

+ NameNEQ *string

+ NameNotIn []string

+ Not *GroupWhereInput

+ Or []*GroupWhereInput

+ Predicates []predicate.Group

+ func (i *GroupWhereInput) AddPredicates(predicates ...predicate.Group)

+ func (i *GroupWhereInput) Filter(q *GroupQuery) (*GroupQuery, error)

+ func (i *GroupWhereInput) P() (predicate.Group, error)

+ type Groups []*Group

type Todo

+ CategoryID int

type TodoCreate

+ func (c *TodoCreate) SetInput(i CreateTodoInput) *TodoCreate

type TodoMutation

+ func (m *TodoMutation) CategoryIDCleared() bool

+ func (m *TodoMutation) ClearCategoryID()

+ func (m *TodoMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *TodoMutation) OldCategoryID(ctx context.Context) (v int, err error)

+ func (m *TodoMutation) ResetCategoryID()

type TodoUpdate

+ func (tu *TodoUpdate) ClearCategoryID() *TodoUpdate

type TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearCategoryID() *TodoUpdateOne

type TodoWhereInput

+ CategoryID *int

+ CategoryIDIn []int

+ CategoryIDIsNil bool

+ CategoryIDNEQ *int

+ CategoryIDNotIn []int

+ CategoryIDNotNil bool

+ Predicates []predicate.Todo

+ func (i *TodoWhereInput) AddPredicates(predicates ...predicate.Todo)

type Tx

+ Friendship *FriendshipClient

+ Group *GroupClient

+ User *UserClient

+ type UpdateUserInput struct

+ AddFriendIDs []int

+ AddGroupIDs []int

+ Name *string

+ RemoveFriendIDs []int

+ RemoveGroupIDs []int

+ func (i *UpdateUserInput) Mutate(m *UserMutation)

+ type User struct

+ Edges UserEdges

+ ID int

+ Name string

+ func (u *User) Friends(ctx context.Context) ([]*User, error)

+ func (u *User) Friendships(ctx context.Context) ([]*Friendship, error)

+ func (u *User) Groups(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*GroupConnection, error)

+ func (u *User) Node(ctx context.Context) (node *Node, err error)

+ func (u *User) QueryFriends() *UserQuery

+ func (u *User) QueryFriendships() *FriendshipQuery

+ func (u *User) QueryGroups() *GroupQuery

+ func (u *User) String() string

+ func (u *User) ToEdge(order *UserOrder) *UserEdge

+ func (u *User) Unwrap() *User

+ func (u *User) Update() *UserUpdateOne

+ type UserClient struct

+ func NewUserClient(c config) *UserClient

+ func (c *UserClient) Create() *UserCreate

+ func (c *UserClient) CreateBulk(builders ...*UserCreate) *UserCreateBulk

+ func (c *UserClient) Delete() *UserDelete

+ func (c *UserClient) DeleteOne(u *User) *UserDeleteOne

+ func (c *UserClient) DeleteOneID(id int) *UserDeleteOne

+ func (c *UserClient) Get(ctx context.Context, id int) (*User, error)

+ func (c *UserClient) GetX(ctx context.Context, id int) *User

+ func (c *UserClient) Hooks() []Hook

+ func (c *UserClient) Query() *UserQuery

+ func (c *UserClient) QueryFriends(u *User) *UserQuery

+ func (c *UserClient) QueryFriendships(u *User) *FriendshipQuery

+ func (c *UserClient) QueryGroups(u *User) *GroupQuery

+ func (c *UserClient) Update() *UserUpdate

+ func (c *UserClient) UpdateOne(u *User) *UserUpdateOne

+ func (c *UserClient) UpdateOneID(id int) *UserUpdateOne

+ func (c *UserClient) Use(hooks ...Hook)

+ type UserConnection struct

+ Edges []*UserEdge

+ PageInfo PageInfo

+ TotalCount int

+ type UserCreate struct

+ func (c *UserCreate) SetInput(i CreateUserInput) *UserCreate

+ func (uc *UserCreate) AddFriendIDs(ids ...int) *UserCreate

+ func (uc *UserCreate) AddFriends(u ...*User) *UserCreate

+ func (uc *UserCreate) AddFriendshipIDs(ids ...int) *UserCreate

+ func (uc *UserCreate) AddFriendships(f ...*Friendship) *UserCreate

+ func (uc *UserCreate) AddGroupIDs(ids ...int) *UserCreate

+ func (uc *UserCreate) AddGroups(g ...*Group) *UserCreate

+ func (uc *UserCreate) Exec(ctx context.Context) error

+ func (uc *UserCreate) ExecX(ctx context.Context)

+ func (uc *UserCreate) Mutation() *UserMutation

+ func (uc *UserCreate) Save(ctx context.Context) (*User, error)

+ func (uc *UserCreate) SaveX(ctx context.Context) *User

+ func (uc *UserCreate) SetName(s string) *UserCreate

+ func (uc *UserCreate) SetNillableName(s *string) *UserCreate

+ type UserCreateBulk struct

+ func (ucb *UserCreateBulk) Exec(ctx context.Context) error

+ func (ucb *UserCreateBulk) ExecX(ctx context.Context)

+ func (ucb *UserCreateBulk) Save(ctx context.Context) ([]*User, error)

+ func (ucb *UserCreateBulk) SaveX(ctx context.Context) []*User

+ type UserDelete struct

+ func (ud *UserDelete) Exec(ctx context.Context) (int, error)

+ func (ud *UserDelete) ExecX(ctx context.Context) int

+ func (ud *UserDelete) Where(ps ...predicate.User) *UserDelete

+ type UserDeleteOne struct

+ func (udo *UserDeleteOne) Exec(ctx context.Context) error

+ func (udo *UserDeleteOne) ExecX(ctx context.Context)

+ type UserEdge struct

+ Cursor Cursor

+ Node *User

+ type UserEdges struct

+ Friends []*User

+ Friendships []*Friendship

+ Groups []*Group

+ func (e UserEdges) FriendsOrErr() ([]*User, error)

+ func (e UserEdges) FriendshipsOrErr() ([]*Friendship, error)

+ func (e UserEdges) GroupsOrErr() ([]*Group, error)

+ type UserGroupBy struct

+ func (s *UserGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (s *UserGroupBy) BoolX(ctx context.Context) bool

+ func (s *UserGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (s *UserGroupBy) BoolsX(ctx context.Context) []bool

+ func (s *UserGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (s *UserGroupBy) Float64X(ctx context.Context) float64

+ func (s *UserGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (s *UserGroupBy) Float64sX(ctx context.Context) []float64

+ func (s *UserGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (s *UserGroupBy) IntX(ctx context.Context) int

+ func (s *UserGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (s *UserGroupBy) IntsX(ctx context.Context) []int

+ func (s *UserGroupBy) ScanX(ctx context.Context, v interface{})

+ func (s *UserGroupBy) String(ctx context.Context) (_ string, err error)

+ func (s *UserGroupBy) StringX(ctx context.Context) string

+ func (s *UserGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (s *UserGroupBy) StringsX(ctx context.Context) []string

+ func (ugb *UserGroupBy) Aggregate(fns ...AggregateFunc) *UserGroupBy

+ func (ugb *UserGroupBy) Scan(ctx context.Context, v interface{}) error

+ type UserMutation struct

+ func (m *UserMutation) AddField(name string, value ent.Value) error

+ func (m *UserMutation) AddFriendIDs(ids ...int)

+ func (m *UserMutation) AddFriendshipIDs(ids ...int)

+ func (m *UserMutation) AddGroupIDs(ids ...int)

+ func (m *UserMutation) AddedEdges() []string

+ func (m *UserMutation) AddedField(name string) (ent.Value, bool)

+ func (m *UserMutation) AddedFields() []string

+ func (m *UserMutation) AddedIDs(name string) []ent.Value

+ func (m *UserMutation) ClearEdge(name string) error

+ func (m *UserMutation) ClearField(name string) error

+ func (m *UserMutation) ClearFriends()

+ func (m *UserMutation) ClearFriendships()

+ func (m *UserMutation) ClearGroups()

+ func (m *UserMutation) ClearedEdges() []string

+ func (m *UserMutation) ClearedFields() []string

+ func (m *UserMutation) EdgeCleared(name string) bool

+ func (m *UserMutation) Field(name string) (ent.Value, bool)

+ func (m *UserMutation) FieldCleared(name string) bool

+ func (m *UserMutation) Fields() []string

+ func (m *UserMutation) FriendsCleared() bool

+ func (m *UserMutation) FriendsIDs() (ids []int)

+ func (m *UserMutation) FriendshipsCleared() bool

+ func (m *UserMutation) FriendshipsIDs() (ids []int)

+ func (m *UserMutation) GroupsCleared() bool

+ func (m *UserMutation) GroupsIDs() (ids []int)

+ func (m *UserMutation) ID() (id int, exists bool)

+ func (m *UserMutation) IDs(ctx context.Context) ([]int, error)

+ func (m *UserMutation) Name() (r string, exists bool)

+ func (m *UserMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *UserMutation) OldName(ctx context.Context) (v string, err error)

+ func (m *UserMutation) Op() Op

+ func (m *UserMutation) RemoveFriendIDs(ids ...int)

+ func (m *UserMutation) RemoveFriendshipIDs(ids ...int)

+ func (m *UserMutation) RemoveGroupIDs(ids ...int)

+ func (m *UserMutation) RemovedEdges() []string

+ func (m *UserMutation) RemovedFriendsIDs() (ids []int)

+ func (m *UserMutation) RemovedFriendshipsIDs() (ids []int)

+ func (m *UserMutation) RemovedGroupsIDs() (ids []int)

+ func (m *UserMutation) RemovedIDs(name string) []ent.Value

+ func (m *UserMutation) ResetEdge(name string) error

+ func (m *UserMutation) ResetField(name string) error

+ func (m *UserMutation) ResetFriends()

+ func (m *UserMutation) ResetFriendships()

+ func (m *UserMutation) ResetGroups()

+ func (m *UserMutation) ResetName()

+ func (m *UserMutation) SetField(name string, value ent.Value) error

+ func (m *UserMutation) SetName(s string)

+ func (m *UserMutation) Type() string

+ func (m *UserMutation) Where(ps ...predicate.User)

+ func (m UserMutation) Client() *Client

+ func (m UserMutation) Tx() (*Tx, error)

+ type UserOrder struct

+ Direction OrderDirection

+ Field *UserOrderField

+ type UserOrderField struct

+ type UserPaginateOption func(*userPager) error

+ func WithUserFilter(filter func(*UserQuery) (*UserQuery, error)) UserPaginateOption

+ func WithUserOrder(order *UserOrder) UserPaginateOption

+ type UserQuery struct

+ func (u *UserQuery) CollectFields(ctx context.Context, satisfies ...string) (*UserQuery, error)

+ func (u *UserQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*UserConnection, error)

+ func (uq *UserQuery) All(ctx context.Context) ([]*User, error)

+ func (uq *UserQuery) AllX(ctx context.Context) []*User

+ func (uq *UserQuery) Clone() *UserQuery

+ func (uq *UserQuery) Count(ctx context.Context) (int, error)

+ func (uq *UserQuery) CountX(ctx context.Context) int

+ func (uq *UserQuery) Exist(ctx context.Context) (bool, error)

+ func (uq *UserQuery) ExistX(ctx context.Context) bool

+ func (uq *UserQuery) First(ctx context.Context) (*User, error)

+ func (uq *UserQuery) FirstID(ctx context.Context) (id int, err error)

+ func (uq *UserQuery) FirstIDX(ctx context.Context) int

+ func (uq *UserQuery) FirstX(ctx context.Context) *User

+ func (uq *UserQuery) GroupBy(field string, fields ...string) *UserGroupBy

+ func (uq *UserQuery) IDs(ctx context.Context) ([]int, error)

+ func (uq *UserQuery) IDsX(ctx context.Context) []int

+ func (uq *UserQuery) Limit(limit int) *UserQuery

+ func (uq *UserQuery) Offset(offset int) *UserQuery

+ func (uq *UserQuery) Only(ctx context.Context) (*User, error)

+ func (uq *UserQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (uq *UserQuery) OnlyIDX(ctx context.Context) int

+ func (uq *UserQuery) OnlyX(ctx context.Context) *User

+ func (uq *UserQuery) Order(o ...OrderFunc) *UserQuery

+ func (uq *UserQuery) QueryFriends() *UserQuery

+ func (uq *UserQuery) QueryFriendships() *FriendshipQuery

+ func (uq *UserQuery) QueryGroups() *GroupQuery

+ func (uq *UserQuery) Select(fields ...string) *UserSelect

+ func (uq *UserQuery) Unique(unique bool) *UserQuery

+ func (uq *UserQuery) Where(ps ...predicate.User) *UserQuery

+ func (uq *UserQuery) WithFriends(opts ...func(*UserQuery)) *UserQuery

+ func (uq *UserQuery) WithFriendships(opts ...func(*FriendshipQuery)) *UserQuery

+ func (uq *UserQuery) WithGroups(opts ...func(*GroupQuery)) *UserQuery

+ type UserSelect struct

+ func (s *UserSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (s *UserSelect) BoolX(ctx context.Context) bool

+ func (s *UserSelect) Bools(ctx context.Context) ([]bool, error)

+ func (s *UserSelect) BoolsX(ctx context.Context) []bool

+ func (s *UserSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (s *UserSelect) Float64X(ctx context.Context) float64

+ func (s *UserSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (s *UserSelect) Float64sX(ctx context.Context) []float64

+ func (s *UserSelect) Int(ctx context.Context) (_ int, err error)

+ func (s *UserSelect) IntX(ctx context.Context) int

+ func (s *UserSelect) Ints(ctx context.Context) ([]int, error)

+ func (s *UserSelect) IntsX(ctx context.Context) []int

+ func (s *UserSelect) ScanX(ctx context.Context, v interface{})

+ func (s *UserSelect) String(ctx context.Context) (_ string, err error)

+ func (s *UserSelect) StringX(ctx context.Context) string

+ func (s *UserSelect) Strings(ctx context.Context) ([]string, error)

+ func (s *UserSelect) StringsX(ctx context.Context) []string

+ func (us *UserSelect) Scan(ctx context.Context, v interface{}) error

+ type UserUpdate struct

+ func (c *UserUpdate) SetInput(i UpdateUserInput) *UserUpdate

+ func (uu *UserUpdate) AddFriendIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) AddFriends(u ...*User) *UserUpdate

+ func (uu *UserUpdate) AddFriendshipIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) AddFriendships(f ...*Friendship) *UserUpdate

+ func (uu *UserUpdate) AddGroupIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) AddGroups(g ...*Group) *UserUpdate

+ func (uu *UserUpdate) ClearFriends() *UserUpdate

+ func (uu *UserUpdate) ClearFriendships() *UserUpdate

+ func (uu *UserUpdate) ClearGroups() *UserUpdate

+ func (uu *UserUpdate) Exec(ctx context.Context) error

+ func (uu *UserUpdate) ExecX(ctx context.Context)

+ func (uu *UserUpdate) Mutation() *UserMutation

+ func (uu *UserUpdate) RemoveFriendIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) RemoveFriends(u ...*User) *UserUpdate

+ func (uu *UserUpdate) RemoveFriendshipIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) RemoveFriendships(f ...*Friendship) *UserUpdate

+ func (uu *UserUpdate) RemoveGroupIDs(ids ...int) *UserUpdate

+ func (uu *UserUpdate) RemoveGroups(g ...*Group) *UserUpdate

+ func (uu *UserUpdate) Save(ctx context.Context) (int, error)

+ func (uu *UserUpdate) SaveX(ctx context.Context) int

+ func (uu *UserUpdate) SetName(s string) *UserUpdate

+ func (uu *UserUpdate) SetNillableName(s *string) *UserUpdate

+ func (uu *UserUpdate) Where(ps ...predicate.User) *UserUpdate

+ type UserUpdateOne struct

+ func (c *UserUpdateOne) SetInput(i UpdateUserInput) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddFriendIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddFriends(u ...*User) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddFriendshipIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddFriendships(f ...*Friendship) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddGroupIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) AddGroups(g ...*Group) *UserUpdateOne

+ func (uuo *UserUpdateOne) ClearFriends() *UserUpdateOne

+ func (uuo *UserUpdateOne) ClearFriendships() *UserUpdateOne

+ func (uuo *UserUpdateOne) ClearGroups() *UserUpdateOne

+ func (uuo *UserUpdateOne) Exec(ctx context.Context) error

+ func (uuo *UserUpdateOne) ExecX(ctx context.Context)

+ func (uuo *UserUpdateOne) Mutation() *UserMutation

+ func (uuo *UserUpdateOne) RemoveFriendIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) RemoveFriends(u ...*User) *UserUpdateOne

+ func (uuo *UserUpdateOne) RemoveFriendshipIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) RemoveFriendships(f ...*Friendship) *UserUpdateOne

+ func (uuo *UserUpdateOne) RemoveGroupIDs(ids ...int) *UserUpdateOne

+ func (uuo *UserUpdateOne) RemoveGroups(g ...*Group) *UserUpdateOne

+ func (uuo *UserUpdateOne) Save(ctx context.Context) (*User, error)

+ func (uuo *UserUpdateOne) SaveX(ctx context.Context) *User

+ func (uuo *UserUpdateOne) Select(field string, fields ...string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetName(s string) *UserUpdateOne

+ func (uuo *UserUpdateOne) SetNillableName(s *string) *UserUpdateOne

+ type UserWhereInput struct

+ And []*UserWhereInput

+ HasFriends *bool

+ HasFriendsWith []*UserWhereInput

+ HasFriendships *bool

+ HasFriendshipsWith []*FriendshipWhereInput

+ HasGroups *bool

+ HasGroupsWith []*GroupWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Name *string

+ NameContains *string

+ NameContainsFold *string

+ NameEqualFold *string

+ NameGT *string

+ NameGTE *string

+ NameHasPrefix *string

+ NameHasSuffix *string

+ NameIn []string

+ NameLT *string

+ NameLTE *string

+ NameNEQ *string

+ NameNotIn []string

+ Not *UserWhereInput

+ Or []*UserWhereInput

+ Predicates []predicate.User

+ func (i *UserWhereInput) AddPredicates(predicates ...predicate.User)

+ func (i *UserWhereInput) Filter(q *UserQuery) (*UserQuery, error)

+ func (i *UserWhereInput) P() (predicate.User, error)

+ type Users []*User

type VerySecretMutation

+ func (m *VerySecretMutation) IDs(ctx context.Context) ([]int, error)

v0.2.0

Nov 20, 2021

Changes in this version

+ var CategoryOrderFieldDuration = &CategoryOrderField

type Category

+ Count uint64

+ Duration time.Duration

type CategoryCreate

+ func (cc *CategoryCreate) Exec(ctx context.Context) error

+ func (cc *CategoryCreate) ExecX(ctx context.Context)

+ func (cc *CategoryCreate) SetCount(u uint64) *CategoryCreate

+ func (cc *CategoryCreate) SetDuration(t time.Duration) *CategoryCreate

+ func (cc *CategoryCreate) SetNillableCount(u *uint64) *CategoryCreate

+ func (cc *CategoryCreate) SetNillableDuration(t *time.Duration) *CategoryCreate

type CategoryCreateBulk

+ func (ccb *CategoryCreateBulk) Exec(ctx context.Context) error

+ func (ccb *CategoryCreateBulk) ExecX(ctx context.Context)

type CategoryMutation

+ func (m *CategoryMutation) AddCount(u uint64)

+ func (m *CategoryMutation) AddDuration(t time.Duration)

+ func (m *CategoryMutation) AddedCount() (r uint64, exists bool)

+ func (m *CategoryMutation) AddedDuration() (r time.Duration, exists bool)

+ func (m *CategoryMutation) ClearCount()

+ func (m *CategoryMutation) ClearDuration()

+ func (m *CategoryMutation) Count() (r uint64, exists bool)

+ func (m *CategoryMutation) CountCleared() bool

+ func (m *CategoryMutation) Duration() (r time.Duration, exists bool)

+ func (m *CategoryMutation) DurationCleared() bool

+ func (m *CategoryMutation) OldCount(ctx context.Context) (v uint64, err error)

+ func (m *CategoryMutation) OldDuration(ctx context.Context) (v time.Duration, err error)

+ func (m *CategoryMutation) ResetCount()

+ func (m *CategoryMutation) ResetDuration()

+ func (m *CategoryMutation) SetCount(u uint64)

+ func (m *CategoryMutation) SetDuration(t time.Duration)

+ func (m *CategoryMutation) Where(ps ...predicate.Category)

type CategoryUpdate

+ func (cu *CategoryUpdate) AddCount(u uint64) *CategoryUpdate

+ func (cu *CategoryUpdate) AddDuration(t time.Duration) *CategoryUpdate

+ func (cu *CategoryUpdate) ClearCount() *CategoryUpdate

+ func (cu *CategoryUpdate) ClearDuration() *CategoryUpdate

+ func (cu *CategoryUpdate) SetCount(u uint64) *CategoryUpdate

+ func (cu *CategoryUpdate) SetDuration(t time.Duration) *CategoryUpdate

+ func (cu *CategoryUpdate) SetNillableCount(u *uint64) *CategoryUpdate

+ func (cu *CategoryUpdate) SetNillableDuration(t *time.Duration) *CategoryUpdate

type CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AddCount(u uint64) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AddDuration(t time.Duration) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearCount() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearDuration() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetCount(u uint64) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetDuration(t time.Duration) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetNillableCount(u *uint64) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetNillableDuration(t *time.Duration) *CategoryUpdateOne

type CategoryWhereInput

+ Count *uint64

+ CountGT *uint64

+ CountGTE *uint64

+ CountIn []uint64

+ CountIsNil bool

+ CountLT *uint64

+ CountLTE *uint64

+ CountNEQ *uint64

+ CountNotIn []uint64

+ CountNotNil bool

+ Duration *time.Duration

+ DurationGT *time.Duration

+ DurationGTE *time.Duration

+ DurationIn []time.Duration

+ DurationIsNil bool

+ DurationLT *time.Duration

+ DurationLTE *time.Duration

+ DurationNEQ *time.Duration

+ DurationNotIn []time.Duration

+ DurationNotNil bool

type TodoCreate

+ func (tc *TodoCreate) Exec(ctx context.Context) error

+ func (tc *TodoCreate) ExecX(ctx context.Context)

type TodoCreateBulk

+ func (tcb *TodoCreateBulk) Exec(ctx context.Context) error

+ func (tcb *TodoCreateBulk) ExecX(ctx context.Context)

type TodoMutation

+ func (m *TodoMutation) Where(ps ...predicate.Todo)

type VerySecretCreate

+ func (vsc *VerySecretCreate) Exec(ctx context.Context) error

+ func (vsc *VerySecretCreate) ExecX(ctx context.Context)

type VerySecretCreateBulk

+ func (vscb *VerySecretCreateBulk) Exec(ctx context.Context) error

+ func (vscb *VerySecretCreateBulk) ExecX(ctx context.Context)

type VerySecretMutation

+ func (m *VerySecretMutation) Where(ps ...predicate.VerySecret)

v0.1.0

Aug 17, 2021

Changes in this version

+ const OpCreate

+ const OpDelete

+ const OpDeleteOne

+ const OpUpdate

+ const OpUpdateOne

+ const TypeCategory

+ const TypeTodo

+ const TypeVerySecret

+ var CategoryOrderFieldText = &CategoryOrderField

+ var DefaultCategoryOrder = &CategoryOrder

+ var DefaultTodoOrder = &TodoOrder

+ var TodoOrderFieldCreatedAt = &TodoOrderField

+ var TodoOrderFieldPriority = &TodoOrderField

+ var TodoOrderFieldStatus = &TodoOrderField

+ var TodoOrderFieldText = &TodoOrderField

+ func IsConstraintError(err error) bool

+ func IsNotFound(err error) bool

+ func IsNotLoaded(err error) bool

+ func IsNotSingular(err error) bool

+ func IsValidationError(err error) bool

+ func MaskNotFound(err error) error

+ func NewContext(parent context.Context, c *Client) context.Context

+ func NewTxContext(parent context.Context, tx *Tx) context.Context

+ func OpenTxFromContext(ctx context.Context) (context.Context, driver.Tx, error)

+ type AggregateFunc func(*sql.Selector) string

+ func As(fn AggregateFunc, end string) AggregateFunc

+ func Count() AggregateFunc

+ func Max(field string) AggregateFunc

+ func Mean(field string) AggregateFunc

+ func Min(field string) AggregateFunc

+ func Sum(field string) AggregateFunc

+ type Categories []*Category

+ type Category struct

+ Config *schematype.CategoryConfig

+ Edges CategoryEdges

+ ID int

+ Status category.Status

+ Text string

+ func (c *Category) Node(ctx context.Context) (node *Node, err error)

+ func (c *Category) QueryTodos() *TodoQuery

+ func (c *Category) String() string

+ func (c *Category) ToEdge(order *CategoryOrder) *CategoryEdge

+ func (c *Category) Todos(ctx context.Context) ([]*Todo, error)

+ func (c *Category) Unwrap() *Category

+ func (c *Category) Update() *CategoryUpdateOne

+ type CategoryClient struct

+ func NewCategoryClient(c config) *CategoryClient

+ func (c *CategoryClient) Create() *CategoryCreate

+ func (c *CategoryClient) CreateBulk(builders ...*CategoryCreate) *CategoryCreateBulk

+ func (c *CategoryClient) Delete() *CategoryDelete

+ func (c *CategoryClient) DeleteOne(ca *Category) *CategoryDeleteOne

+ func (c *CategoryClient) DeleteOneID(id int) *CategoryDeleteOne

+ func (c *CategoryClient) Get(ctx context.Context, id int) (*Category, error)

+ func (c *CategoryClient) GetX(ctx context.Context, id int) *Category

+ func (c *CategoryClient) Hooks() []Hook

+ func (c *CategoryClient) Query() *CategoryQuery

+ func (c *CategoryClient) QueryTodos(ca *Category) *TodoQuery

+ func (c *CategoryClient) Update() *CategoryUpdate

+ func (c *CategoryClient) UpdateOne(ca *Category) *CategoryUpdateOne

+ func (c *CategoryClient) UpdateOneID(id int) *CategoryUpdateOne

+ func (c *CategoryClient) Use(hooks ...Hook)

+ type CategoryConnection struct

+ Edges []*CategoryEdge

+ PageInfo PageInfo

+ TotalCount int

+ type CategoryCreate struct

+ func (cc *CategoryCreate) AddTodoIDs(ids ...int) *CategoryCreate

+ func (cc *CategoryCreate) AddTodos(t ...*Todo) *CategoryCreate

+ func (cc *CategoryCreate) Mutation() *CategoryMutation

+ func (cc *CategoryCreate) Save(ctx context.Context) (*Category, error)

+ func (cc *CategoryCreate) SaveX(ctx context.Context) *Category

+ func (cc *CategoryCreate) SetConfig(sc *schematype.CategoryConfig) *CategoryCreate

+ func (cc *CategoryCreate) SetStatus(c category.Status) *CategoryCreate

+ func (cc *CategoryCreate) SetText(s string) *CategoryCreate

+ type CategoryCreateBulk struct

+ func (ccb *CategoryCreateBulk) Save(ctx context.Context) ([]*Category, error)

+ func (ccb *CategoryCreateBulk) SaveX(ctx context.Context) []*Category

+ type CategoryDelete struct

+ func (cd *CategoryDelete) Exec(ctx context.Context) (int, error)

+ func (cd *CategoryDelete) ExecX(ctx context.Context) int

+ func (cd *CategoryDelete) Where(ps ...predicate.Category) *CategoryDelete

+ type CategoryDeleteOne struct

+ func (cdo *CategoryDeleteOne) Exec(ctx context.Context) error

+ func (cdo *CategoryDeleteOne) ExecX(ctx context.Context)

+ type CategoryEdge struct

+ Cursor Cursor

+ Node *Category

+ type CategoryEdges struct

+ Todos []*Todo

+ func (e CategoryEdges) TodosOrErr() ([]*Todo, error)

+ type CategoryGroupBy struct

+ func (cgb *CategoryGroupBy) Aggregate(fns ...AggregateFunc) *CategoryGroupBy

+ func (cgb *CategoryGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (cgb *CategoryGroupBy) BoolX(ctx context.Context) bool

+ func (cgb *CategoryGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (cgb *CategoryGroupBy) BoolsX(ctx context.Context) []bool

+ func (cgb *CategoryGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (cgb *CategoryGroupBy) Float64X(ctx context.Context) float64

+ func (cgb *CategoryGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (cgb *CategoryGroupBy) Float64sX(ctx context.Context) []float64

+ func (cgb *CategoryGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (cgb *CategoryGroupBy) IntX(ctx context.Context) int

+ func (cgb *CategoryGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (cgb *CategoryGroupBy) IntsX(ctx context.Context) []int

+ func (cgb *CategoryGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (cgb *CategoryGroupBy) ScanX(ctx context.Context, v interface{})

+ func (cgb *CategoryGroupBy) String(ctx context.Context) (_ string, err error)

+ func (cgb *CategoryGroupBy) StringX(ctx context.Context) string

+ func (cgb *CategoryGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (cgb *CategoryGroupBy) StringsX(ctx context.Context) []string

+ type CategoryMutation struct

+ func (m *CategoryMutation) AddField(name string, value ent.Value) error

+ func (m *CategoryMutation) AddTodoIDs(ids ...int)

+ func (m *CategoryMutation) AddedEdges() []string

+ func (m *CategoryMutation) AddedField(name string) (ent.Value, bool)

+ func (m *CategoryMutation) AddedFields() []string

+ func (m *CategoryMutation) AddedIDs(name string) []ent.Value

+ func (m *CategoryMutation) ClearConfig()

+ func (m *CategoryMutation) ClearEdge(name string) error

+ func (m *CategoryMutation) ClearField(name string) error

+ func (m *CategoryMutation) ClearTodos()

+ func (m *CategoryMutation) ClearedEdges() []string

+ func (m *CategoryMutation) ClearedFields() []string

+ func (m *CategoryMutation) Config() (r *schematype.CategoryConfig, exists bool)

+ func (m *CategoryMutation) ConfigCleared() bool

+ func (m *CategoryMutation) EdgeCleared(name string) bool

+ func (m *CategoryMutation) Field(name string) (ent.Value, bool)

+ func (m *CategoryMutation) FieldCleared(name string) bool

+ func (m *CategoryMutation) Fields() []string

+ func (m *CategoryMutation) ID() (id int, exists bool)

+ func (m *CategoryMutation) OldConfig(ctx context.Context) (v *schematype.CategoryConfig, err error)

+ func (m *CategoryMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *CategoryMutation) OldStatus(ctx context.Context) (v category.Status, err error)

+ func (m *CategoryMutation) OldText(ctx context.Context) (v string, err error)

+ func (m *CategoryMutation) Op() Op

+ func (m *CategoryMutation) RemoveTodoIDs(ids ...int)

+ func (m *CategoryMutation) RemovedEdges() []string

+ func (m *CategoryMutation) RemovedIDs(name string) []ent.Value

+ func (m *CategoryMutation) RemovedTodosIDs() (ids []int)

+ func (m *CategoryMutation) ResetConfig()

+ func (m *CategoryMutation) ResetEdge(name string) error

+ func (m *CategoryMutation) ResetField(name string) error

+ func (m *CategoryMutation) ResetStatus()

+ func (m *CategoryMutation) ResetText()

+ func (m *CategoryMutation) ResetTodos()

+ func (m *CategoryMutation) SetConfig(sc *schematype.CategoryConfig)

+ func (m *CategoryMutation) SetField(name string, value ent.Value) error

+ func (m *CategoryMutation) SetStatus(c category.Status)

+ func (m *CategoryMutation) SetText(s string)

+ func (m *CategoryMutation) Status() (r category.Status, exists bool)

+ func (m *CategoryMutation) Text() (r string, exists bool)

+ func (m *CategoryMutation) TodosCleared() bool

+ func (m *CategoryMutation) TodosIDs() (ids []int)

+ func (m *CategoryMutation) Type() string

+ func (m CategoryMutation) Client() *Client

+ func (m CategoryMutation) Tx() (*Tx, error)

+ type CategoryOrder struct

+ Direction OrderDirection

+ Field *CategoryOrderField

+ type CategoryOrderField struct

+ func (f *CategoryOrderField) UnmarshalGQL(v interface{}) error

+ func (f CategoryOrderField) MarshalGQL(w io.Writer)

+ func (f CategoryOrderField) String() string

+ type CategoryPaginateOption func(*categoryPager) error

+ func WithCategoryFilter(filter func(*CategoryQuery) (*CategoryQuery, error)) CategoryPaginateOption

+ func WithCategoryOrder(order *CategoryOrder) CategoryPaginateOption

+ type CategoryQuery struct

+ func (c *CategoryQuery) CollectFields(ctx context.Context, satisfies ...string) *CategoryQuery

+ func (c *CategoryQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*CategoryConnection, error)

+ func (cq *CategoryQuery) All(ctx context.Context) ([]*Category, error)

+ func (cq *CategoryQuery) AllX(ctx context.Context) []*Category

+ func (cq *CategoryQuery) Clone() *CategoryQuery

+ func (cq *CategoryQuery) Count(ctx context.Context) (int, error)

+ func (cq *CategoryQuery) CountX(ctx context.Context) int

+ func (cq *CategoryQuery) Exist(ctx context.Context) (bool, error)

+ func (cq *CategoryQuery) ExistX(ctx context.Context) bool

+ func (cq *CategoryQuery) First(ctx context.Context) (*Category, error)

+ func (cq *CategoryQuery) FirstID(ctx context.Context) (id int, err error)

+ func (cq *CategoryQuery) FirstIDX(ctx context.Context) int

+ func (cq *CategoryQuery) FirstX(ctx context.Context) *Category

+ func (cq *CategoryQuery) GroupBy(field string, fields ...string) *CategoryGroupBy

+ func (cq *CategoryQuery) IDs(ctx context.Context) ([]int, error)

+ func (cq *CategoryQuery) IDsX(ctx context.Context) []int

+ func (cq *CategoryQuery) Limit(limit int) *CategoryQuery

+ func (cq *CategoryQuery) Offset(offset int) *CategoryQuery

+ func (cq *CategoryQuery) Only(ctx context.Context) (*Category, error)

+ func (cq *CategoryQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (cq *CategoryQuery) OnlyIDX(ctx context.Context) int

+ func (cq *CategoryQuery) OnlyX(ctx context.Context) *Category

+ func (cq *CategoryQuery) Order(o ...OrderFunc) *CategoryQuery

+ func (cq *CategoryQuery) QueryTodos() *TodoQuery

+ func (cq *CategoryQuery) Select(field string, fields ...string) *CategorySelect

+ func (cq *CategoryQuery) Unique(unique bool) *CategoryQuery

+ func (cq *CategoryQuery) Where(ps ...predicate.Category) *CategoryQuery

+ func (cq *CategoryQuery) WithTodos(opts ...func(*TodoQuery)) *CategoryQuery

+ type CategorySelect struct

+ func (cs *CategorySelect) Bool(ctx context.Context) (_ bool, err error)

+ func (cs *CategorySelect) BoolX(ctx context.Context) bool

+ func (cs *CategorySelect) Bools(ctx context.Context) ([]bool, error)

+ func (cs *CategorySelect) BoolsX(ctx context.Context) []bool

+ func (cs *CategorySelect) Float64(ctx context.Context) (_ float64, err error)

+ func (cs *CategorySelect) Float64X(ctx context.Context) float64

+ func (cs *CategorySelect) Float64s(ctx context.Context) ([]float64, error)

+ func (cs *CategorySelect) Float64sX(ctx context.Context) []float64

+ func (cs *CategorySelect) Int(ctx context.Context) (_ int, err error)

+ func (cs *CategorySelect) IntX(ctx context.Context) int

+ func (cs *CategorySelect) Ints(ctx context.Context) ([]int, error)

+ func (cs *CategorySelect) IntsX(ctx context.Context) []int

+ func (cs *CategorySelect) Scan(ctx context.Context, v interface{}) error

+ func (cs *CategorySelect) ScanX(ctx context.Context, v interface{})

+ func (cs *CategorySelect) String(ctx context.Context) (_ string, err error)

+ func (cs *CategorySelect) StringX(ctx context.Context) string

+ func (cs *CategorySelect) Strings(ctx context.Context) ([]string, error)

+ func (cs *CategorySelect) StringsX(ctx context.Context) []string

+ type CategoryUpdate struct

+ func (cu *CategoryUpdate) AddTodoIDs(ids ...int) *CategoryUpdate

+ func (cu *CategoryUpdate) AddTodos(t ...*Todo) *CategoryUpdate

+ func (cu *CategoryUpdate) ClearConfig() *CategoryUpdate

+ func (cu *CategoryUpdate) ClearTodos() *CategoryUpdate

+ func (cu *CategoryUpdate) Exec(ctx context.Context) error

+ func (cu *CategoryUpdate) ExecX(ctx context.Context)

+ func (cu *CategoryUpdate) Mutation() *CategoryMutation

+ func (cu *CategoryUpdate) RemoveTodoIDs(ids ...int) *CategoryUpdate

+ func (cu *CategoryUpdate) RemoveTodos(t ...*Todo) *CategoryUpdate

+ func (cu *CategoryUpdate) Save(ctx context.Context) (int, error)

+ func (cu *CategoryUpdate) SaveX(ctx context.Context) int

+ func (cu *CategoryUpdate) SetConfig(sc *schematype.CategoryConfig) *CategoryUpdate

+ func (cu *CategoryUpdate) SetStatus(c category.Status) *CategoryUpdate

+ func (cu *CategoryUpdate) SetText(s string) *CategoryUpdate

+ func (cu *CategoryUpdate) Where(ps ...predicate.Category) *CategoryUpdate

+ type CategoryUpdateOne struct

+ func (cuo *CategoryUpdateOne) AddTodoIDs(ids ...int) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) AddTodos(t ...*Todo) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearConfig() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) ClearTodos() *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) Exec(ctx context.Context) error

+ func (cuo *CategoryUpdateOne) ExecX(ctx context.Context)

+ func (cuo *CategoryUpdateOne) Mutation() *CategoryMutation

+ func (cuo *CategoryUpdateOne) RemoveTodoIDs(ids ...int) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) RemoveTodos(t ...*Todo) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) Save(ctx context.Context) (*Category, error)

+ func (cuo *CategoryUpdateOne) SaveX(ctx context.Context) *Category

+ func (cuo *CategoryUpdateOne) Select(field string, fields ...string) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetConfig(sc *schematype.CategoryConfig) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetStatus(c category.Status) *CategoryUpdateOne

+ func (cuo *CategoryUpdateOne) SetText(s string) *CategoryUpdateOne

+ type CategoryWhereInput struct

+ And []*CategoryWhereInput

+ Config *schematype.CategoryConfig

+ ConfigGT *schematype.CategoryConfig

+ ConfigGTE *schematype.CategoryConfig

+ ConfigIn []*schematype.CategoryConfig

+ ConfigIsNil bool

+ ConfigLT *schematype.CategoryConfig

+ ConfigLTE *schematype.CategoryConfig

+ ConfigNEQ *schematype.CategoryConfig

+ ConfigNotIn []*schematype.CategoryConfig

+ ConfigNotNil bool

+ HasTodos *bool

+ HasTodosWith []*TodoWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Not *CategoryWhereInput

+ Or []*CategoryWhereInput

+ Status *category.Status

+ StatusIn []category.Status

+ StatusNEQ *category.Status

+ StatusNotIn []category.Status

+ Text *string

+ TextContains *string

+ TextContainsFold *string

+ TextEqualFold *string

+ TextGT *string

+ TextGTE *string

+ TextHasPrefix *string

+ TextHasSuffix *string

+ TextIn []string

+ TextLT *string

+ TextLTE *string

+ TextNEQ *string

+ TextNotIn []string

+ func (i *CategoryWhereInput) Filter(q *CategoryQuery) (*CategoryQuery, error)

+ func (i *CategoryWhereInput) P() (predicate.Category, error)

+ type Client struct

+ Category *CategoryClient

+ Schema *migrate.Schema

+ Todo *TodoClient

+ VerySecret *VerySecretClient

+ func FromContext(ctx context.Context) *Client

+ func NewClient(opts ...Option) *Client

+ func Open(driverName, dataSourceName string, options ...Option) (*Client, error)

+ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)

+ func (c *Client) Close() error

+ func (c *Client) Debug() *Client

+ func (c *Client) Node(ctx context.Context, id int) (*Node, error)

+ func (c *Client) Noder(ctx context.Context, id int, opts ...NodeOption) (_ Noder, err error)

+ func (c *Client) Noders(ctx context.Context, ids []int, opts ...NodeOption) ([]Noder, error)

+ func (c *Client) OpenTx(ctx context.Context) (context.Context, driver.Tx, error)

+ func (c *Client) Tx(ctx context.Context) (*Tx, error)

+ func (c *Client) Use(hooks ...Hook)

+ type CommitFunc func(context.Context, *Tx) error

+ func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error

+ type CommitHook func(Committer) Committer

+ type Committer interface

+ Commit func(context.Context, *Tx) error

+ type ConstraintError struct

+ func (e *ConstraintError) Unwrap() error

+ func (e ConstraintError) Error() string

+ type Cursor struct

+ ID int

+ Value Value

+ func (c *Cursor) UnmarshalGQL(v interface{}) error

+ func (c Cursor) MarshalGQL(w io.Writer)

+ type Edge struct

+ IDs []int

+ Name string

+ Type string

+ type Field struct

+ Name string

+ Type string

+ Value string

+ type Hook = ent.Hook

+ type MutateFunc = ent.MutateFunc

+ type Mutation = ent.Mutation

+ type Mutator = ent.Mutator

+ type Node struct

+ Edges []*Edge

+ Fields []*Field

+ ID int

+ Type string

+ type NodeOption func(*nodeOptions)

+ func WithFixedNodeType(t string) NodeOption

+ func WithNodeType(f func(context.Context, int) (string, error)) NodeOption

+ type Noder interface

+ Node func(context.Context) (*Node, error)

+ type NotFoundError struct

+ func (e *NotFoundError) Error() string

+ type NotLoadedError struct

+ func (e *NotLoadedError) Error() string

+ type NotSingularError struct

+ func (e *NotSingularError) Error() string

+ type Op = ent.Op

+ type Option func(*config)

+ func Debug() Option

+ func Driver(driver dialect.Driver) Option

+ func Log(fn func(...interface{})) Option

+ type OrderDirection string

+ const OrderDirectionAsc

+ const OrderDirectionDesc

+ func (o *OrderDirection) UnmarshalGQL(val interface{}) error

+ func (o OrderDirection) MarshalGQL(w io.Writer)

+ func (o OrderDirection) String() string

+ func (o OrderDirection) Validate() error

+ type OrderFunc func(*sql.Selector)

+ func Asc(fields ...string) OrderFunc

+ func Desc(fields ...string) OrderFunc

+ type PageInfo struct

+ EndCursor *Cursor

+ HasNextPage bool

+ HasPreviousPage bool

+ StartCursor *Cursor

+ type Policy = ent.Policy

+ type Query = ent.Query

+ type RollbackFunc func(context.Context, *Tx) error

+ func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error

+ type RollbackHook func(Rollbacker) Rollbacker

+ type Rollbacker interface

+ Rollback func(context.Context, *Tx) error

+ type Todo struct

+ Blob []byte

+ CreatedAt time.Time

+ Edges TodoEdges

+ ID int

+ Priority int

+ Status todo.Status

+ Text string

+ func (t *Todo) Category(ctx context.Context) (*Category, error)

+ func (t *Todo) Children(ctx context.Context) ([]*Todo, error)

+ func (t *Todo) Node(ctx context.Context) (node *Node, err error)

+ func (t *Todo) Parent(ctx context.Context) (*Todo, error)

+ func (t *Todo) QueryCategory() *CategoryQuery

+ func (t *Todo) QueryChildren() *TodoQuery

+ func (t *Todo) QueryParent() *TodoQuery

+ func (t *Todo) QuerySecret() *VerySecretQuery

+ func (t *Todo) String() string

+ func (t *Todo) ToEdge(order *TodoOrder) *TodoEdge

+ func (t *Todo) Unwrap() *Todo

+ func (t *Todo) Update() *TodoUpdateOne

+ type TodoClient struct

+ func NewTodoClient(c config) *TodoClient

+ func (c *TodoClient) Create() *TodoCreate

+ func (c *TodoClient) CreateBulk(builders ...*TodoCreate) *TodoCreateBulk

+ func (c *TodoClient) Delete() *TodoDelete

+ func (c *TodoClient) DeleteOne(t *Todo) *TodoDeleteOne

+ func (c *TodoClient) DeleteOneID(id int) *TodoDeleteOne

+ func (c *TodoClient) Get(ctx context.Context, id int) (*Todo, error)

+ func (c *TodoClient) GetX(ctx context.Context, id int) *Todo

+ func (c *TodoClient) Hooks() []Hook

+ func (c *TodoClient) Query() *TodoQuery

+ func (c *TodoClient) QueryCategory(t *Todo) *CategoryQuery

+ func (c *TodoClient) QueryChildren(t *Todo) *TodoQuery

+ func (c *TodoClient) QueryParent(t *Todo) *TodoQuery

+ func (c *TodoClient) QuerySecret(t *Todo) *VerySecretQuery

+ func (c *TodoClient) Update() *TodoUpdate

+ func (c *TodoClient) UpdateOne(t *Todo) *TodoUpdateOne

+ func (c *TodoClient) UpdateOneID(id int) *TodoUpdateOne

+ func (c *TodoClient) Use(hooks ...Hook)

+ type TodoConnection struct

+ Edges []*TodoEdge

+ PageInfo PageInfo

+ TotalCount int

+ type TodoCreate struct

+ func (tc *TodoCreate) AddChildIDs(ids ...int) *TodoCreate

+ func (tc *TodoCreate) AddChildren(t ...*Todo) *TodoCreate

+ func (tc *TodoCreate) Mutation() *TodoMutation

+ func (tc *TodoCreate) Save(ctx context.Context) (*Todo, error)

+ func (tc *TodoCreate) SaveX(ctx context.Context) *Todo

+ func (tc *TodoCreate) SetBlob(b []byte) *TodoCreate

+ func (tc *TodoCreate) SetCategory(c *Category) *TodoCreate

+ func (tc *TodoCreate) SetCategoryID(id int) *TodoCreate

+ func (tc *TodoCreate) SetCreatedAt(t time.Time) *TodoCreate

+ func (tc *TodoCreate) SetNillableCategoryID(id *int) *TodoCreate

+ func (tc *TodoCreate) SetNillableCreatedAt(t *time.Time) *TodoCreate

+ func (tc *TodoCreate) SetNillableParentID(id *int) *TodoCreate

+ func (tc *TodoCreate) SetNillablePriority(i *int) *TodoCreate

+ func (tc *TodoCreate) SetNillableSecretID(id *int) *TodoCreate

+ func (tc *TodoCreate) SetParent(t *Todo) *TodoCreate

+ func (tc *TodoCreate) SetParentID(id int) *TodoCreate

+ func (tc *TodoCreate) SetPriority(i int) *TodoCreate

+ func (tc *TodoCreate) SetSecret(v *VerySecret) *TodoCreate

+ func (tc *TodoCreate) SetSecretID(id int) *TodoCreate

+ func (tc *TodoCreate) SetStatus(t todo.Status) *TodoCreate

+ func (tc *TodoCreate) SetText(s string) *TodoCreate

+ type TodoCreateBulk struct

+ func (tcb *TodoCreateBulk) Save(ctx context.Context) ([]*Todo, error)

+ func (tcb *TodoCreateBulk) SaveX(ctx context.Context) []*Todo

+ type TodoDelete struct

+ func (td *TodoDelete) Exec(ctx context.Context) (int, error)

+ func (td *TodoDelete) ExecX(ctx context.Context) int

+ func (td *TodoDelete) Where(ps ...predicate.Todo) *TodoDelete

+ type TodoDeleteOne struct

+ func (tdo *TodoDeleteOne) Exec(ctx context.Context) error

+ func (tdo *TodoDeleteOne) ExecX(ctx context.Context)

+ type TodoEdge struct

+ Cursor Cursor

+ Node *Todo

+ type TodoEdges struct

+ Category *Category

+ Children []*Todo

+ Parent *Todo

+ Secret *VerySecret

+ func (e TodoEdges) CategoryOrErr() (*Category, error)

+ func (e TodoEdges) ChildrenOrErr() ([]*Todo, error)

+ func (e TodoEdges) ParentOrErr() (*Todo, error)

+ func (e TodoEdges) SecretOrErr() (*VerySecret, error)

+ type TodoGroupBy struct

+ func (tgb *TodoGroupBy) Aggregate(fns ...AggregateFunc) *TodoGroupBy

+ func (tgb *TodoGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (tgb *TodoGroupBy) BoolX(ctx context.Context) bool

+ func (tgb *TodoGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (tgb *TodoGroupBy) BoolsX(ctx context.Context) []bool

+ func (tgb *TodoGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (tgb *TodoGroupBy) Float64X(ctx context.Context) float64

+ func (tgb *TodoGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (tgb *TodoGroupBy) Float64sX(ctx context.Context) []float64

+ func (tgb *TodoGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (tgb *TodoGroupBy) IntX(ctx context.Context) int

+ func (tgb *TodoGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (tgb *TodoGroupBy) IntsX(ctx context.Context) []int

+ func (tgb *TodoGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (tgb *TodoGroupBy) ScanX(ctx context.Context, v interface{})

+ func (tgb *TodoGroupBy) String(ctx context.Context) (_ string, err error)

+ func (tgb *TodoGroupBy) StringX(ctx context.Context) string

+ func (tgb *TodoGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (tgb *TodoGroupBy) StringsX(ctx context.Context) []string

+ type TodoMutation struct

+ func (m *TodoMutation) AddChildIDs(ids ...int)

+ func (m *TodoMutation) AddField(name string, value ent.Value) error

+ func (m *TodoMutation) AddPriority(i int)

+ func (m *TodoMutation) AddedEdges() []string

+ func (m *TodoMutation) AddedField(name string) (ent.Value, bool)

+ func (m *TodoMutation) AddedFields() []string

+ func (m *TodoMutation) AddedIDs(name string) []ent.Value

+ func (m *TodoMutation) AddedPriority() (r int, exists bool)

+ func (m *TodoMutation) Blob() (r []byte, exists bool)

+ func (m *TodoMutation) BlobCleared() bool

+ func (m *TodoMutation) CategoryCleared() bool

+ func (m *TodoMutation) CategoryID() (id int, exists bool)

+ func (m *TodoMutation) CategoryIDs() (ids []int)

+ func (m *TodoMutation) ChildrenCleared() bool

+ func (m *TodoMutation) ChildrenIDs() (ids []int)

+ func (m *TodoMutation) ClearBlob()

+ func (m *TodoMutation) ClearCategory()

+ func (m *TodoMutation) ClearChildren()

+ func (m *TodoMutation) ClearEdge(name string) error

+ func (m *TodoMutation) ClearField(name string) error

+ func (m *TodoMutation) ClearParent()

+ func (m *TodoMutation) ClearSecret()

+ func (m *TodoMutation) ClearedEdges() []string

+ func (m *TodoMutation) ClearedFields() []string

+ func (m *TodoMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *TodoMutation) EdgeCleared(name string) bool

+ func (m *TodoMutation) Field(name string) (ent.Value, bool)

+ func (m *TodoMutation) FieldCleared(name string) bool

+ func (m *TodoMutation) Fields() []string

+ func (m *TodoMutation) ID() (id int, exists bool)

+ func (m *TodoMutation) OldBlob(ctx context.Context) (v []byte, err error)

+ func (m *TodoMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *TodoMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *TodoMutation) OldPriority(ctx context.Context) (v int, err error)

+ func (m *TodoMutation) OldStatus(ctx context.Context) (v todo.Status, err error)

+ func (m *TodoMutation) OldText(ctx context.Context) (v string, err error)

+ func (m *TodoMutation) Op() Op

+ func (m *TodoMutation) ParentCleared() bool

+ func (m *TodoMutation) ParentID() (id int, exists bool)

+ func (m *TodoMutation) ParentIDs() (ids []int)

+ func (m *TodoMutation) Priority() (r int, exists bool)

+ func (m *TodoMutation) RemoveChildIDs(ids ...int)

+ func (m *TodoMutation) RemovedChildrenIDs() (ids []int)

+ func (m *TodoMutation) RemovedEdges() []string

+ func (m *TodoMutation) RemovedIDs(name string) []ent.Value

+ func (m *TodoMutation) ResetBlob()

+ func (m *TodoMutation) ResetCategory()

+ func (m *TodoMutation) ResetChildren()

+ func (m *TodoMutation) ResetCreatedAt()

+ func (m *TodoMutation) ResetEdge(name string) error

+ func (m *TodoMutation) ResetField(name string) error

+ func (m *TodoMutation) ResetParent()

+ func (m *TodoMutation) ResetPriority()

+ func (m *TodoMutation) ResetSecret()

+ func (m *TodoMutation) ResetStatus()

+ func (m *TodoMutation) ResetText()

+ func (m *TodoMutation) SecretCleared() bool

+ func (m *TodoMutation) SecretID() (id int, exists bool)

+ func (m *TodoMutation) SecretIDs() (ids []int)

+ func (m *TodoMutation) SetBlob(b []byte)

+ func (m *TodoMutation) SetCategoryID(id int)

+ func (m *TodoMutation) SetCreatedAt(t time.Time)

+ func (m *TodoMutation) SetField(name string, value ent.Value) error

+ func (m *TodoMutation) SetParentID(id int)

+ func (m *TodoMutation) SetPriority(i int)

+ func (m *TodoMutation) SetSecretID(id int)

+ func (m *TodoMutation) SetStatus(t todo.Status)

+ func (m *TodoMutation) SetText(s string)

+ func (m *TodoMutation) Status() (r todo.Status, exists bool)

+ func (m *TodoMutation) Text() (r string, exists bool)

+ func (m *TodoMutation) Type() string

+ func (m TodoMutation) Client() *Client

+ func (m TodoMutation) Tx() (*Tx, error)

+ type TodoOrder struct

+ Direction OrderDirection

+ Field *TodoOrderField

+ type TodoOrderField struct

+ func (f *TodoOrderField) UnmarshalGQL(v interface{}) error

+ func (f TodoOrderField) MarshalGQL(w io.Writer)

+ func (f TodoOrderField) String() string

+ type TodoPaginateOption func(*todoPager) error

+ func WithTodoFilter(filter func(*TodoQuery) (*TodoQuery, error)) TodoPaginateOption

+ func WithTodoOrder(order *TodoOrder) TodoPaginateOption

+ type TodoQuery struct

+ func (t *TodoQuery) CollectFields(ctx context.Context, satisfies ...string) *TodoQuery

+ func (t *TodoQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*TodoConnection, error)

+ func (tq *TodoQuery) All(ctx context.Context) ([]*Todo, error)

+ func (tq *TodoQuery) AllX(ctx context.Context) []*Todo

+ func (tq *TodoQuery) Clone() *TodoQuery

+ func (tq *TodoQuery) Count(ctx context.Context) (int, error)

+ func (tq *TodoQuery) CountX(ctx context.Context) int

+ func (tq *TodoQuery) Exist(ctx context.Context) (bool, error)

+ func (tq *TodoQuery) ExistX(ctx context.Context) bool

+ func (tq *TodoQuery) First(ctx context.Context) (*Todo, error)

+ func (tq *TodoQuery) FirstID(ctx context.Context) (id int, err error)

+ func (tq *TodoQuery) FirstIDX(ctx context.Context) int

+ func (tq *TodoQuery) FirstX(ctx context.Context) *Todo

+ func (tq *TodoQuery) GroupBy(field string, fields ...string) *TodoGroupBy

+ func (tq *TodoQuery) IDs(ctx context.Context) ([]int, error)

+ func (tq *TodoQuery) IDsX(ctx context.Context) []int

+ func (tq *TodoQuery) Limit(limit int) *TodoQuery

+ func (tq *TodoQuery) Offset(offset int) *TodoQuery

+ func (tq *TodoQuery) Only(ctx context.Context) (*Todo, error)

+ func (tq *TodoQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (tq *TodoQuery) OnlyIDX(ctx context.Context) int

+ func (tq *TodoQuery) OnlyX(ctx context.Context) *Todo

+ func (tq *TodoQuery) Order(o ...OrderFunc) *TodoQuery

+ func (tq *TodoQuery) QueryCategory() *CategoryQuery

+ func (tq *TodoQuery) QueryChildren() *TodoQuery

+ func (tq *TodoQuery) QueryParent() *TodoQuery

+ func (tq *TodoQuery) QuerySecret() *VerySecretQuery

+ func (tq *TodoQuery) Select(field string, fields ...string) *TodoSelect

+ func (tq *TodoQuery) Unique(unique bool) *TodoQuery

+ func (tq *TodoQuery) Where(ps ...predicate.Todo) *TodoQuery

+ func (tq *TodoQuery) WithCategory(opts ...func(*CategoryQuery)) *TodoQuery

+ func (tq *TodoQuery) WithChildren(opts ...func(*TodoQuery)) *TodoQuery

+ func (tq *TodoQuery) WithParent(opts ...func(*TodoQuery)) *TodoQuery

+ func (tq *TodoQuery) WithSecret(opts ...func(*VerySecretQuery)) *TodoQuery

+ type TodoSelect struct

+ func (ts *TodoSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (ts *TodoSelect) BoolX(ctx context.Context) bool

+ func (ts *TodoSelect) Bools(ctx context.Context) ([]bool, error)

+ func (ts *TodoSelect) BoolsX(ctx context.Context) []bool

+ func (ts *TodoSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (ts *TodoSelect) Float64X(ctx context.Context) float64

+ func (ts *TodoSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (ts *TodoSelect) Float64sX(ctx context.Context) []float64

+ func (ts *TodoSelect) Int(ctx context.Context) (_ int, err error)

+ func (ts *TodoSelect) IntX(ctx context.Context) int

+ func (ts *TodoSelect) Ints(ctx context.Context) ([]int, error)

+ func (ts *TodoSelect) IntsX(ctx context.Context) []int

+ func (ts *TodoSelect) Scan(ctx context.Context, v interface{}) error

+ func (ts *TodoSelect) ScanX(ctx context.Context, v interface{})

+ func (ts *TodoSelect) String(ctx context.Context) (_ string, err error)

+ func (ts *TodoSelect) StringX(ctx context.Context) string

+ func (ts *TodoSelect) Strings(ctx context.Context) ([]string, error)

+ func (ts *TodoSelect) StringsX(ctx context.Context) []string

+ type TodoUpdate struct

+ func (tu *TodoUpdate) AddChildIDs(ids ...int) *TodoUpdate

+ func (tu *TodoUpdate) AddChildren(t ...*Todo) *TodoUpdate

+ func (tu *TodoUpdate) AddPriority(i int) *TodoUpdate

+ func (tu *TodoUpdate) ClearBlob() *TodoUpdate

+ func (tu *TodoUpdate) ClearCategory() *TodoUpdate

+ func (tu *TodoUpdate) ClearChildren() *TodoUpdate

+ func (tu *TodoUpdate) ClearParent() *TodoUpdate

+ func (tu *TodoUpdate) ClearSecret() *TodoUpdate

+ func (tu *TodoUpdate) Exec(ctx context.Context) error

+ func (tu *TodoUpdate) ExecX(ctx context.Context)

+ func (tu *TodoUpdate) Mutation() *TodoMutation

+ func (tu *TodoUpdate) RemoveChildIDs(ids ...int) *TodoUpdate

+ func (tu *TodoUpdate) RemoveChildren(t ...*Todo) *TodoUpdate

+ func (tu *TodoUpdate) Save(ctx context.Context) (int, error)

+ func (tu *TodoUpdate) SaveX(ctx context.Context) int

+ func (tu *TodoUpdate) SetBlob(b []byte) *TodoUpdate

+ func (tu *TodoUpdate) SetCategory(c *Category) *TodoUpdate

+ func (tu *TodoUpdate) SetCategoryID(id int) *TodoUpdate

+ func (tu *TodoUpdate) SetNillableCategoryID(id *int) *TodoUpdate

+ func (tu *TodoUpdate) SetNillableParentID(id *int) *TodoUpdate

+ func (tu *TodoUpdate) SetNillablePriority(i *int) *TodoUpdate

+ func (tu *TodoUpdate) SetNillableSecretID(id *int) *TodoUpdate

+ func (tu *TodoUpdate) SetParent(t *Todo) *TodoUpdate

+ func (tu *TodoUpdate) SetParentID(id int) *TodoUpdate

+ func (tu *TodoUpdate) SetPriority(i int) *TodoUpdate

+ func (tu *TodoUpdate) SetSecret(v *VerySecret) *TodoUpdate

+ func (tu *TodoUpdate) SetSecretID(id int) *TodoUpdate

+ func (tu *TodoUpdate) SetStatus(t todo.Status) *TodoUpdate

+ func (tu *TodoUpdate) SetText(s string) *TodoUpdate

+ func (tu *TodoUpdate) Where(ps ...predicate.Todo) *TodoUpdate

+ type TodoUpdateOne struct

+ func (tuo *TodoUpdateOne) AddChildIDs(ids ...int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) AddChildren(t ...*Todo) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) AddPriority(i int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearBlob() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearCategory() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearChildren() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearParent() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) ClearSecret() *TodoUpdateOne

+ func (tuo *TodoUpdateOne) Exec(ctx context.Context) error

+ func (tuo *TodoUpdateOne) ExecX(ctx context.Context)

+ func (tuo *TodoUpdateOne) Mutation() *TodoMutation

+ func (tuo *TodoUpdateOne) RemoveChildIDs(ids ...int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) RemoveChildren(t ...*Todo) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) Save(ctx context.Context) (*Todo, error)

+ func (tuo *TodoUpdateOne) SaveX(ctx context.Context) *Todo

+ func (tuo *TodoUpdateOne) Select(field string, fields ...string) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetBlob(b []byte) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetCategory(c *Category) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetCategoryID(id int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillableCategoryID(id *int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillableParentID(id *int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillablePriority(i *int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetNillableSecretID(id *int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetParent(t *Todo) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetParentID(id int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetPriority(i int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetSecret(v *VerySecret) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetSecretID(id int) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetStatus(t todo.Status) *TodoUpdateOne

+ func (tuo *TodoUpdateOne) SetText(s string) *TodoUpdateOne

+ type TodoWhereInput struct

+ And []*TodoWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasCategory *bool

+ HasCategoryWith []*CategoryWhereInput

+ HasChildren *bool

+ HasChildrenWith []*TodoWhereInput

+ HasParent *bool

+ HasParentWith []*TodoWhereInput

+ ID *int

+ IDGT *int

+ IDGTE *int

+ IDIn []int

+ IDLT *int

+ IDLTE *int

+ IDNEQ *int

+ IDNotIn []int

+ Not *TodoWhereInput

+ Or []*TodoWhereInput

+ Priority *int

+ PriorityGT *int

+ PriorityGTE *int

+ PriorityIn []int

+ PriorityLT *int

+ PriorityLTE *int

+ PriorityNEQ *int

+ PriorityNotIn []int

+ Status *todo.Status

+ StatusIn []todo.Status

+ StatusNEQ *todo.Status

+ StatusNotIn []todo.Status

+ Text *string

+ TextContains *string

+ TextContainsFold *string

+ TextEqualFold *string

+ TextGT *string

+ TextGTE *string

+ TextHasPrefix *string

+ TextHasSuffix *string

+ TextIn []string

+ TextLT *string

+ TextLTE *string

+ TextNEQ *string

+ TextNotIn []string

+ func (i *TodoWhereInput) Filter(q *TodoQuery) (*TodoQuery, error)

+ func (i *TodoWhereInput) P() (predicate.Todo, error)

+ type Todos []*Todo

+ type Tx struct

+ Category *CategoryClient

+ Todo *TodoClient

+ VerySecret *VerySecretClient

+ func TxFromContext(ctx context.Context) *Tx

+ func (tx *Tx) Client() *Client

+ func (tx *Tx) Commit() error

+ func (tx *Tx) OnCommit(f CommitHook)

+ func (tx *Tx) OnRollback(f RollbackHook)

+ func (tx *Tx) Rollback() error

+ type ValidationError struct

+ Name string

+ func (e *ValidationError) Error() string

+ func (e *ValidationError) Unwrap() error

+ type Value = ent.Value

+ type VerySecret struct

+ ID int

+ Password string

+ func (vs *VerySecret) String() string

+ func (vs *VerySecret) Unwrap() *VerySecret

+ func (vs *VerySecret) Update() *VerySecretUpdateOne

+ type VerySecretClient struct

+ func NewVerySecretClient(c config) *VerySecretClient

+ func (c *VerySecretClient) Create() *VerySecretCreate

+ func (c *VerySecretClient) CreateBulk(builders ...*VerySecretCreate) *VerySecretCreateBulk

+ func (c *VerySecretClient) Delete() *VerySecretDelete

+ func (c *VerySecretClient) DeleteOne(vs *VerySecret) *VerySecretDeleteOne

+ func (c *VerySecretClient) DeleteOneID(id int) *VerySecretDeleteOne

+ func (c *VerySecretClient) Get(ctx context.Context, id int) (*VerySecret, error)

+ func (c *VerySecretClient) GetX(ctx context.Context, id int) *VerySecret

+ func (c *VerySecretClient) Hooks() []Hook

+ func (c *VerySecretClient) Query() *VerySecretQuery

+ func (c *VerySecretClient) Update() *VerySecretUpdate

+ func (c *VerySecretClient) UpdateOne(vs *VerySecret) *VerySecretUpdateOne

+ func (c *VerySecretClient) UpdateOneID(id int) *VerySecretUpdateOne

+ func (c *VerySecretClient) Use(hooks ...Hook)

+ type VerySecretCreate struct

+ func (vsc *VerySecretCreate) Mutation() *VerySecretMutation

+ func (vsc *VerySecretCreate) Save(ctx context.Context) (*VerySecret, error)

+ func (vsc *VerySecretCreate) SaveX(ctx context.Context) *VerySecret

+ func (vsc *VerySecretCreate) SetPassword(s string) *VerySecretCreate

+ type VerySecretCreateBulk struct

+ func (vscb *VerySecretCreateBulk) Save(ctx context.Context) ([]*VerySecret, error)

+ func (vscb *VerySecretCreateBulk) SaveX(ctx context.Context) []*VerySecret

+ type VerySecretDelete struct

+ func (vsd *VerySecretDelete) Exec(ctx context.Context) (int, error)

+ func (vsd *VerySecretDelete) ExecX(ctx context.Context) int

+ func (vsd *VerySecretDelete) Where(ps ...predicate.VerySecret) *VerySecretDelete

+ type VerySecretDeleteOne struct

+ func (vsdo *VerySecretDeleteOne) Exec(ctx context.Context) error

+ func (vsdo *VerySecretDeleteOne) ExecX(ctx context.Context)

+ type VerySecretGroupBy struct

+ func (vsgb *VerySecretGroupBy) Aggregate(fns ...AggregateFunc) *VerySecretGroupBy

+ func (vsgb *VerySecretGroupBy) Bool(ctx context.Context) (_ bool, err error)

+ func (vsgb *VerySecretGroupBy) BoolX(ctx context.Context) bool

+ func (vsgb *VerySecretGroupBy) Bools(ctx context.Context) ([]bool, error)

+ func (vsgb *VerySecretGroupBy) BoolsX(ctx context.Context) []bool

+ func (vsgb *VerySecretGroupBy) Float64(ctx context.Context) (_ float64, err error)

+ func (vsgb *VerySecretGroupBy) Float64X(ctx context.Context) float64

+ func (vsgb *VerySecretGroupBy) Float64s(ctx context.Context) ([]float64, error)

+ func (vsgb *VerySecretGroupBy) Float64sX(ctx context.Context) []float64

+ func (vsgb *VerySecretGroupBy) Int(ctx context.Context) (_ int, err error)

+ func (vsgb *VerySecretGroupBy) IntX(ctx context.Context) int

+ func (vsgb *VerySecretGroupBy) Ints(ctx context.Context) ([]int, error)

+ func (vsgb *VerySecretGroupBy) IntsX(ctx context.Context) []int

+ func (vsgb *VerySecretGroupBy) Scan(ctx context.Context, v interface{}) error

+ func (vsgb *VerySecretGroupBy) ScanX(ctx context.Context, v interface{})

+ func (vsgb *VerySecretGroupBy) String(ctx context.Context) (_ string, err error)

+ func (vsgb *VerySecretGroupBy) StringX(ctx context.Context) string

+ func (vsgb *VerySecretGroupBy) Strings(ctx context.Context) ([]string, error)

+ func (vsgb *VerySecretGroupBy) StringsX(ctx context.Context) []string

+ type VerySecretMutation struct

+ func (m *VerySecretMutation) AddField(name string, value ent.Value) error

+ func (m *VerySecretMutation) AddedEdges() []string

+ func (m *VerySecretMutation) AddedField(name string) (ent.Value, bool)

+ func (m *VerySecretMutation) AddedFields() []string

+ func (m *VerySecretMutation) AddedIDs(name string) []ent.Value

+ func (m *VerySecretMutation) ClearEdge(name string) error

+ func (m *VerySecretMutation) ClearField(name string) error

+ func (m *VerySecretMutation) ClearedEdges() []string

+ func (m *VerySecretMutation) ClearedFields() []string

+ func (m *VerySecretMutation) EdgeCleared(name string) bool

+ func (m *VerySecretMutation) Field(name string) (ent.Value, bool)

+ func (m *VerySecretMutation) FieldCleared(name string) bool

+ func (m *VerySecretMutation) Fields() []string

+ func (m *VerySecretMutation) ID() (id int, exists bool)

+ func (m *VerySecretMutation) OldField(ctx context.Context, name string) (ent.Value, error)

+ func (m *VerySecretMutation) OldPassword(ctx context.Context) (v string, err error)

+ func (m *VerySecretMutation) Op() Op

+ func (m *VerySecretMutation) Password() (r string, exists bool)

+ func (m *VerySecretMutation) RemovedEdges() []string

+ func (m *VerySecretMutation) RemovedIDs(name string) []ent.Value

+ func (m *VerySecretMutation) ResetEdge(name string) error

+ func (m *VerySecretMutation) ResetField(name string) error

+ func (m *VerySecretMutation) ResetPassword()

+ func (m *VerySecretMutation) SetField(name string, value ent.Value) error

+ func (m *VerySecretMutation) SetPassword(s string)

+ func (m *VerySecretMutation) Type() string

+ func (m VerySecretMutation) Client() *Client

+ func (m VerySecretMutation) Tx() (*Tx, error)

+ type VerySecretQuery struct

+ func (vsq *VerySecretQuery) All(ctx context.Context) ([]*VerySecret, error)

+ func (vsq *VerySecretQuery) AllX(ctx context.Context) []*VerySecret

+ func (vsq *VerySecretQuery) Clone() *VerySecretQuery

+ func (vsq *VerySecretQuery) Count(ctx context.Context) (int, error)

+ func (vsq *VerySecretQuery) CountX(ctx context.Context) int

+ func (vsq *VerySecretQuery) Exist(ctx context.Context) (bool, error)

+ func (vsq *VerySecretQuery) ExistX(ctx context.Context) bool

+ func (vsq *VerySecretQuery) First(ctx context.Context) (*VerySecret, error)

+ func (vsq *VerySecretQuery) FirstID(ctx context.Context) (id int, err error)

+ func (vsq *VerySecretQuery) FirstIDX(ctx context.Context) int

+ func (vsq *VerySecretQuery) FirstX(ctx context.Context) *VerySecret

+ func (vsq *VerySecretQuery) GroupBy(field string, fields ...string) *VerySecretGroupBy

+ func (vsq *VerySecretQuery) IDs(ctx context.Context) ([]int, error)

+ func (vsq *VerySecretQuery) IDsX(ctx context.Context) []int

+ func (vsq *VerySecretQuery) Limit(limit int) *VerySecretQuery

+ func (vsq *VerySecretQuery) Offset(offset int) *VerySecretQuery

+ func (vsq *VerySecretQuery) Only(ctx context.Context) (*VerySecret, error)

+ func (vsq *VerySecretQuery) OnlyID(ctx context.Context) (id int, err error)

+ func (vsq *VerySecretQuery) OnlyIDX(ctx context.Context) int

+ func (vsq *VerySecretQuery) OnlyX(ctx context.Context) *VerySecret

+ func (vsq *VerySecretQuery) Order(o ...OrderFunc) *VerySecretQuery

+ func (vsq *VerySecretQuery) Select(field string, fields ...string) *VerySecretSelect

+ func (vsq *VerySecretQuery) Unique(unique bool) *VerySecretQuery

+ func (vsq *VerySecretQuery) Where(ps ...predicate.VerySecret) *VerySecretQuery

+ type VerySecretSelect struct

+ func (vss *VerySecretSelect) Bool(ctx context.Context) (_ bool, err error)

+ func (vss *VerySecretSelect) BoolX(ctx context.Context) bool

+ func (vss *VerySecretSelect) Bools(ctx context.Context) ([]bool, error)

+ func (vss *VerySecretSelect) BoolsX(ctx context.Context) []bool

+ func (vss *VerySecretSelect) Float64(ctx context.Context) (_ float64, err error)

+ func (vss *VerySecretSelect) Float64X(ctx context.Context) float64

+ func (vss *VerySecretSelect) Float64s(ctx context.Context) ([]float64, error)

+ func (vss *VerySecretSelect) Float64sX(ctx context.Context) []float64

+ func (vss *VerySecretSelect) Int(ctx context.Context) (_ int, err error)

+ func (vss *VerySecretSelect) IntX(ctx context.Context) int

+ func (vss *VerySecretSelect) Ints(ctx context.Context) ([]int, error)

+ func (vss *VerySecretSelect) IntsX(ctx context.Context) []int

+ func (vss *VerySecretSelect) Scan(ctx context.Context, v interface{}) error

+ func (vss *VerySecretSelect) ScanX(ctx context.Context, v interface{})

+ func (vss *VerySecretSelect) String(ctx context.Context) (_ string, err error)

+ func (vss *VerySecretSelect) StringX(ctx context.Context) string

+ func (vss *VerySecretSelect) Strings(ctx context.Context) ([]string, error)

+ func (vss *VerySecretSelect) StringsX(ctx context.Context) []string

+ type VerySecretUpdate struct

+ func (vsu *VerySecretUpdate) Exec(ctx context.Context) error

+ func (vsu *VerySecretUpdate) ExecX(ctx context.Context)

+ func (vsu *VerySecretUpdate) Mutation() *VerySecretMutation

+ func (vsu *VerySecretUpdate) Save(ctx context.Context) (int, error)

+ func (vsu *VerySecretUpdate) SaveX(ctx context.Context) int

+ func (vsu *VerySecretUpdate) SetPassword(s string) *VerySecretUpdate

+ func (vsu *VerySecretUpdate) Where(ps ...predicate.VerySecret) *VerySecretUpdate

+ type VerySecretUpdateOne struct

+ func (vsuo *VerySecretUpdateOne) Exec(ctx context.Context) error

+ func (vsuo *VerySecretUpdateOne) ExecX(ctx context.Context)

+ func (vsuo *VerySecretUpdateOne) Mutation() *VerySecretMutation

+ func (vsuo *VerySecretUpdateOne) Save(ctx context.Context) (*VerySecret, error)

+ func (vsuo *VerySecretUpdateOne) SaveX(ctx context.Context) *VerySecret

+ func (vsuo *VerySecretUpdateOne) Select(field string, fields ...string) *VerySecretUpdateOne

+ func (vsuo *VerySecretUpdateOne) SetPassword(s string) *VerySecretUpdateOne

+ type VerySecrets []*VerySecret

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL