generated

package

Go to main page

Versions in this module

v0

v0.3.3

Sep 19, 2024

v0.3.2

Aug 21, 2024

v0.3.1

May 30, 2024

v0.3.0

Mar 28, 2024

v0.2.2

Mar 13, 2024

v0.2.1

Feb 27, 2024

Changes in this version

type LoadBalancerPortWhereInput

+ NameIsNil bool

+ NameNotNil bool

type PortCreate

+ func (pc *PortCreate) SetNillableName(s *string) *PortCreate

type PortMutation

+ func (m *PortMutation) ClearName()

+ func (m *PortMutation) NameCleared() bool

type PortUpdate

+ func (pu *PortUpdate) ClearName() *PortUpdate

+ func (pu *PortUpdate) SetNillableName(s *string) *PortUpdate

type PortUpdateOne

+ func (puo *PortUpdateOne) ClearName() *PortUpdateOne

+ func (puo *PortUpdateOne) SetNillableName(s *string) *PortUpdateOne

type UpdateLoadBalancerPortInput

+ ClearName bool

v0.2.0

Feb 8, 2024

Changes in this version

+ var LoadBalancerOrderFieldCreatedBy = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldDeletedAt = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldDeletedBy = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldUpdatedBy = &LoadBalancerOrderField

+ var OriginOrderFieldCreatedBy = &LoadBalancerOriginOrderField

+ var OriginOrderFieldDeletedAt = &LoadBalancerOriginOrderField

+ var OriginOrderFieldDeletedBy = &LoadBalancerOriginOrderField

+ var OriginOrderFieldUpdatedBy = &LoadBalancerOriginOrderField

+ var PoolOrderFieldCreatedBy = &LoadBalancerPoolOrderField

+ var PoolOrderFieldDeletedAt = &LoadBalancerPoolOrderField

+ var PoolOrderFieldDeletedBy = &LoadBalancerPoolOrderField

+ var PoolOrderFieldUpdatedBy = &LoadBalancerPoolOrderField

+ var PortOrderFieldCreatedBy = &LoadBalancerPortOrderField

+ var PortOrderFieldDeletedAt = &LoadBalancerPortOrderField

+ var PortOrderFieldDeletedBy = &LoadBalancerPortOrderField

+ var PortOrderFieldUpdatedBy = &LoadBalancerPortOrderField

+ var ProviderOrderFieldCreatedBy = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldDeletedAt = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldDeletedBy = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldUpdatedBy = &LoadBalancerProviderOrderField

type LoadBalancer

+ CreatedBy string

+ DeletedAt time.Time

+ DeletedBy string

+ UpdatedBy string

type LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetCreatedBy(s string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetDeletedAt(t time.Time) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetDeletedBy(s string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableCreatedBy(s *string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableDeletedAt(t *time.Time) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableDeletedBy(s *string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableUpdatedBy(s *string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetUpdatedBy(s string) *LoadBalancerCreate

type LoadBalancerMutation

+ func (m *LoadBalancerMutation) ClearCreatedBy()

+ func (m *LoadBalancerMutation) ClearDeletedAt()

+ func (m *LoadBalancerMutation) ClearDeletedBy()

+ func (m *LoadBalancerMutation) ClearUpdatedBy()

+ func (m *LoadBalancerMutation) CreatedBy() (r string, exists bool)

+ func (m *LoadBalancerMutation) CreatedByCleared() bool

+ func (m *LoadBalancerMutation) DeletedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerMutation) DeletedAtCleared() bool

+ func (m *LoadBalancerMutation) DeletedBy() (r string, exists bool)

+ func (m *LoadBalancerMutation) DeletedByCleared() bool

+ func (m *LoadBalancerMutation) OldCreatedBy(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerMutation) OldDeletedBy(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerMutation) OldUpdatedBy(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerMutation) ResetCreatedBy()

+ func (m *LoadBalancerMutation) ResetDeletedAt()

+ func (m *LoadBalancerMutation) ResetDeletedBy()

+ func (m *LoadBalancerMutation) ResetUpdatedBy()

+ func (m *LoadBalancerMutation) SetCreatedBy(s string)

+ func (m *LoadBalancerMutation) SetDeletedAt(t time.Time)

+ func (m *LoadBalancerMutation) SetDeletedBy(s string)

+ func (m *LoadBalancerMutation) SetUpdatedBy(s string)

+ func (m *LoadBalancerMutation) UpdatedBy() (r string, exists bool)

+ func (m *LoadBalancerMutation) UpdatedByCleared() bool

type LoadBalancerOriginWhereInput

+ CreatedBy *string

+ CreatedByContains *string

+ CreatedByContainsFold *string

+ CreatedByEqualFold *string

+ CreatedByGT *string

+ CreatedByGTE *string

+ CreatedByHasPrefix *string

+ CreatedByHasSuffix *string

+ CreatedByIn []string

+ CreatedByIsNil bool

+ CreatedByLT *string

+ CreatedByLTE *string

+ CreatedByNEQ *string

+ CreatedByNotIn []string

+ CreatedByNotNil bool

+ DeletedAt *time.Time

+ DeletedAtGT *time.Time

+ DeletedAtGTE *time.Time

+ DeletedAtIn []time.Time

+ DeletedAtIsNil bool

+ DeletedAtLT *time.Time

+ DeletedAtLTE *time.Time

+ DeletedAtNEQ *time.Time

+ DeletedAtNotIn []time.Time

+ DeletedAtNotNil bool

+ DeletedBy *string

+ DeletedByContains *string

+ DeletedByContainsFold *string

+ DeletedByEqualFold *string

+ DeletedByGT *string

+ DeletedByGTE *string

+ DeletedByHasPrefix *string

+ DeletedByHasSuffix *string

+ DeletedByIn []string

+ DeletedByIsNil bool

+ DeletedByLT *string

+ DeletedByLTE *string

+ DeletedByNEQ *string

+ DeletedByNotIn []string

+ DeletedByNotNil bool

+ UpdatedBy *string

+ UpdatedByContains *string

+ UpdatedByContainsFold *string

+ UpdatedByEqualFold *string

+ UpdatedByGT *string

+ UpdatedByGTE *string

+ UpdatedByHasPrefix *string

+ UpdatedByHasSuffix *string

+ UpdatedByIn []string

+ UpdatedByIsNil bool

+ UpdatedByLT *string

+ UpdatedByLTE *string

+ UpdatedByNEQ *string

+ UpdatedByNotIn []string

+ UpdatedByNotNil bool

type LoadBalancerPoolWhereInput

+ CreatedBy *string

+ CreatedByContains *string

+ CreatedByContainsFold *string

+ CreatedByEqualFold *string

+ CreatedByGT *string

+ CreatedByGTE *string

+ CreatedByHasPrefix *string

+ CreatedByHasSuffix *string

+ CreatedByIn []string

+ CreatedByIsNil bool

+ CreatedByLT *string

+ CreatedByLTE *string

+ CreatedByNEQ *string

+ CreatedByNotIn []string

+ CreatedByNotNil bool

+ DeletedAt *time.Time

+ DeletedAtGT *time.Time

+ DeletedAtGTE *time.Time

+ DeletedAtIn []time.Time

+ DeletedAtIsNil bool

+ DeletedAtLT *time.Time

+ DeletedAtLTE *time.Time

+ DeletedAtNEQ *time.Time

+ DeletedAtNotIn []time.Time

+ DeletedAtNotNil bool

+ DeletedBy *string

+ DeletedByContains *string

+ DeletedByContainsFold *string

+ DeletedByEqualFold *string

+ DeletedByGT *string

+ DeletedByGTE *string

+ DeletedByHasPrefix *string

+ DeletedByHasSuffix *string

+ DeletedByIn []string

+ DeletedByIsNil bool

+ DeletedByLT *string

+ DeletedByLTE *string

+ DeletedByNEQ *string

+ DeletedByNotIn []string

+ DeletedByNotNil bool

+ UpdatedBy *string

+ UpdatedByContains *string

+ UpdatedByContainsFold *string

+ UpdatedByEqualFold *string

+ UpdatedByGT *string

+ UpdatedByGTE *string

+ UpdatedByHasPrefix *string

+ UpdatedByHasSuffix *string

+ UpdatedByIn []string

+ UpdatedByIsNil bool

+ UpdatedByLT *string

+ UpdatedByLTE *string

+ UpdatedByNEQ *string

+ UpdatedByNotIn []string

+ UpdatedByNotNil bool

type LoadBalancerPortWhereInput

+ CreatedBy *string

+ CreatedByContains *string

+ CreatedByContainsFold *string

+ CreatedByEqualFold *string

+ CreatedByGT *string

+ CreatedByGTE *string

+ CreatedByHasPrefix *string

+ CreatedByHasSuffix *string

+ CreatedByIn []string

+ CreatedByIsNil bool

+ CreatedByLT *string

+ CreatedByLTE *string

+ CreatedByNEQ *string

+ CreatedByNotIn []string

+ CreatedByNotNil bool

+ DeletedAt *time.Time

+ DeletedAtGT *time.Time

+ DeletedAtGTE *time.Time

+ DeletedAtIn []time.Time

+ DeletedAtIsNil bool

+ DeletedAtLT *time.Time

+ DeletedAtLTE *time.Time

+ DeletedAtNEQ *time.Time

+ DeletedAtNotIn []time.Time

+ DeletedAtNotNil bool

+ DeletedBy *string

+ DeletedByContains *string

+ DeletedByContainsFold *string

+ DeletedByEqualFold *string

+ DeletedByGT *string

+ DeletedByGTE *string

+ DeletedByHasPrefix *string

+ DeletedByHasSuffix *string

+ DeletedByIn []string

+ DeletedByIsNil bool

+ DeletedByLT *string

+ DeletedByLTE *string

+ DeletedByNEQ *string

+ DeletedByNotIn []string

+ DeletedByNotNil bool

+ UpdatedBy *string

+ UpdatedByContains *string

+ UpdatedByContainsFold *string

+ UpdatedByEqualFold *string

+ UpdatedByGT *string

+ UpdatedByGTE *string

+ UpdatedByHasPrefix *string

+ UpdatedByHasSuffix *string

+ UpdatedByIn []string

+ UpdatedByIsNil bool

+ UpdatedByLT *string

+ UpdatedByLTE *string

+ UpdatedByNEQ *string

+ UpdatedByNotIn []string

+ UpdatedByNotNil bool

type LoadBalancerProviderWhereInput

+ CreatedBy *string

+ CreatedByContains *string

+ CreatedByContainsFold *string

+ CreatedByEqualFold *string

+ CreatedByGT *string

+ CreatedByGTE *string

+ CreatedByHasPrefix *string

+ CreatedByHasSuffix *string

+ CreatedByIn []string

+ CreatedByIsNil bool

+ CreatedByLT *string

+ CreatedByLTE *string

+ CreatedByNEQ *string

+ CreatedByNotIn []string

+ CreatedByNotNil bool

+ DeletedAt *time.Time

+ DeletedAtGT *time.Time

+ DeletedAtGTE *time.Time

+ DeletedAtIn []time.Time

+ DeletedAtIsNil bool

+ DeletedAtLT *time.Time

+ DeletedAtLTE *time.Time

+ DeletedAtNEQ *time.Time

+ DeletedAtNotIn []time.Time

+ DeletedAtNotNil bool

+ DeletedBy *string

+ DeletedByContains *string

+ DeletedByContainsFold *string

+ DeletedByEqualFold *string

+ DeletedByGT *string

+ DeletedByGTE *string

+ DeletedByHasPrefix *string

+ DeletedByHasSuffix *string

+ DeletedByIn []string

+ DeletedByIsNil bool

+ DeletedByLT *string

+ DeletedByLTE *string

+ DeletedByNEQ *string

+ DeletedByNotIn []string

+ DeletedByNotNil bool

+ UpdatedBy *string

+ UpdatedByContains *string

+ UpdatedByContainsFold *string

+ UpdatedByEqualFold *string

+ UpdatedByGT *string

+ UpdatedByGTE *string

+ UpdatedByHasPrefix *string

+ UpdatedByHasSuffix *string

+ UpdatedByIn []string

+ UpdatedByIsNil bool

+ UpdatedByLT *string

+ UpdatedByLTE *string

+ UpdatedByNEQ *string

+ UpdatedByNotIn []string

+ UpdatedByNotNil bool

type LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearDeletedAt() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearDeletedBy() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearUpdatedBy() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetDeletedAt(t time.Time) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetDeletedBy(s string) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetNillableDeletedAt(t *time.Time) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetNillableDeletedBy(s *string) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetNillableUpdatedBy(s *string) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) SetUpdatedBy(s string) *LoadBalancerUpdate

type LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearDeletedAt() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearDeletedBy() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearUpdatedBy() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetDeletedAt(t time.Time) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetDeletedBy(s string) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetNillableDeletedAt(t *time.Time) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetNillableDeletedBy(s *string) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetNillableUpdatedBy(s *string) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetUpdatedBy(s string) *LoadBalancerUpdateOne

type LoadBalancerWhereInput

+ CreatedBy *string

+ CreatedByContains *string

+ CreatedByContainsFold *string

+ CreatedByEqualFold *string

+ CreatedByGT *string

+ CreatedByGTE *string

+ CreatedByHasPrefix *string

+ CreatedByHasSuffix *string

+ CreatedByIn []string

+ CreatedByIsNil bool

+ CreatedByLT *string

+ CreatedByLTE *string

+ CreatedByNEQ *string

+ CreatedByNotIn []string

+ CreatedByNotNil bool

+ DeletedAt *time.Time

+ DeletedAtGT *time.Time

+ DeletedAtGTE *time.Time

+ DeletedAtIn []time.Time

+ DeletedAtIsNil bool

+ DeletedAtLT *time.Time

+ DeletedAtLTE *time.Time

+ DeletedAtNEQ *time.Time

+ DeletedAtNotIn []time.Time

+ DeletedAtNotNil bool

+ DeletedBy *string

+ DeletedByContains *string

+ DeletedByContainsFold *string

+ DeletedByEqualFold *string

+ DeletedByGT *string

+ DeletedByGTE *string

+ DeletedByHasPrefix *string

+ DeletedByHasSuffix *string

+ DeletedByIn []string

+ DeletedByIsNil bool

+ DeletedByLT *string

+ DeletedByLTE *string

+ DeletedByNEQ *string

+ DeletedByNotIn []string

+ DeletedByNotNil bool

+ UpdatedBy *string

+ UpdatedByContains *string

+ UpdatedByContainsFold *string

+ UpdatedByEqualFold *string

+ UpdatedByGT *string

+ UpdatedByGTE *string

+ UpdatedByHasPrefix *string

+ UpdatedByHasSuffix *string

+ UpdatedByIn []string

+ UpdatedByIsNil bool

+ UpdatedByLT *string

+ UpdatedByLTE *string

+ UpdatedByNEQ *string

+ UpdatedByNotIn []string

+ UpdatedByNotNil bool

type Origin

+ CreatedBy string

+ DeletedAt time.Time

+ DeletedBy string

+ UpdatedBy string

type OriginCreate

+ func (oc *OriginCreate) SetCreatedBy(s string) *OriginCreate

+ func (oc *OriginCreate) SetDeletedAt(t time.Time) *OriginCreate

+ func (oc *OriginCreate) SetDeletedBy(s string) *OriginCreate

+ func (oc *OriginCreate) SetNillableCreatedBy(s *string) *OriginCreate

+ func (oc *OriginCreate) SetNillableDeletedAt(t *time.Time) *OriginCreate

+ func (oc *OriginCreate) SetNillableDeletedBy(s *string) *OriginCreate

+ func (oc *OriginCreate) SetNillableUpdatedBy(s *string) *OriginCreate

+ func (oc *OriginCreate) SetUpdatedBy(s string) *OriginCreate

type OriginMutation

+ func (m *OriginMutation) ClearCreatedBy()

+ func (m *OriginMutation) ClearDeletedAt()

+ func (m *OriginMutation) ClearDeletedBy()

+ func (m *OriginMutation) ClearUpdatedBy()

+ func (m *OriginMutation) CreatedBy() (r string, exists bool)

+ func (m *OriginMutation) CreatedByCleared() bool

+ func (m *OriginMutation) DeletedAt() (r time.Time, exists bool)

+ func (m *OriginMutation) DeletedAtCleared() bool

+ func (m *OriginMutation) DeletedBy() (r string, exists bool)

+ func (m *OriginMutation) DeletedByCleared() bool

+ func (m *OriginMutation) OldCreatedBy(ctx context.Context) (v string, err error)

+ func (m *OriginMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error)

+ func (m *OriginMutation) OldDeletedBy(ctx context.Context) (v string, err error)

+ func (m *OriginMutation) OldUpdatedBy(ctx context.Context) (v string, err error)

+ func (m *OriginMutation) ResetCreatedBy()

+ func (m *OriginMutation) ResetDeletedAt()

+ func (m *OriginMutation) ResetDeletedBy()

+ func (m *OriginMutation) ResetUpdatedBy()

+ func (m *OriginMutation) SetCreatedBy(s string)

+ func (m *OriginMutation) SetDeletedAt(t time.Time)

+ func (m *OriginMutation) SetDeletedBy(s string)

+ func (m *OriginMutation) SetUpdatedBy(s string)

+ func (m *OriginMutation) UpdatedBy() (r string, exists bool)

+ func (m *OriginMutation) UpdatedByCleared() bool

type OriginUpdate

+ func (ou *OriginUpdate) ClearDeletedAt() *OriginUpdate

+ func (ou *OriginUpdate) ClearDeletedBy() *OriginUpdate

+ func (ou *OriginUpdate) ClearUpdatedBy() *OriginUpdate

+ func (ou *OriginUpdate) SetDeletedAt(t time.Time) *OriginUpdate

+ func (ou *OriginUpdate) SetDeletedBy(s string) *OriginUpdate

+ func (ou *OriginUpdate) SetNillableDeletedAt(t *time.Time) *OriginUpdate

+ func (ou *OriginUpdate) SetNillableDeletedBy(s *string) *OriginUpdate

+ func (ou *OriginUpdate) SetNillableUpdatedBy(s *string) *OriginUpdate

+ func (ou *OriginUpdate) SetUpdatedBy(s string) *OriginUpdate

type OriginUpdateOne

+ func (ouo *OriginUpdateOne) ClearDeletedAt() *OriginUpdateOne

+ func (ouo *OriginUpdateOne) ClearDeletedBy() *OriginUpdateOne

+ func (ouo *OriginUpdateOne) ClearUpdatedBy() *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetDeletedAt(t time.Time) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetDeletedBy(s string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetNillableDeletedAt(t *time.Time) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetNillableDeletedBy(s *string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetNillableUpdatedBy(s *string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetUpdatedBy(s string) *OriginUpdateOne

type Pool

+ CreatedBy string

+ DeletedAt time.Time

+ DeletedBy string

+ UpdatedBy string

type PoolCreate

+ func (pc *PoolCreate) SetCreatedBy(s string) *PoolCreate

+ func (pc *PoolCreate) SetDeletedAt(t time.Time) *PoolCreate

+ func (pc *PoolCreate) SetDeletedBy(s string) *PoolCreate

+ func (pc *PoolCreate) SetNillableCreatedBy(s *string) *PoolCreate

+ func (pc *PoolCreate) SetNillableDeletedAt(t *time.Time) *PoolCreate

+ func (pc *PoolCreate) SetNillableDeletedBy(s *string) *PoolCreate

+ func (pc *PoolCreate) SetNillableUpdatedBy(s *string) *PoolCreate

+ func (pc *PoolCreate) SetUpdatedBy(s string) *PoolCreate

type PoolMutation

+ func (m *PoolMutation) ClearCreatedBy()

+ func (m *PoolMutation) ClearDeletedAt()

+ func (m *PoolMutation) ClearDeletedBy()

+ func (m *PoolMutation) ClearUpdatedBy()

+ func (m *PoolMutation) CreatedBy() (r string, exists bool)

+ func (m *PoolMutation) CreatedByCleared() bool

+ func (m *PoolMutation) DeletedAt() (r time.Time, exists bool)

+ func (m *PoolMutation) DeletedAtCleared() bool

+ func (m *PoolMutation) DeletedBy() (r string, exists bool)

+ func (m *PoolMutation) DeletedByCleared() bool

+ func (m *PoolMutation) OldCreatedBy(ctx context.Context) (v string, err error)

+ func (m *PoolMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PoolMutation) OldDeletedBy(ctx context.Context) (v string, err error)

+ func (m *PoolMutation) OldUpdatedBy(ctx context.Context) (v string, err error)

+ func (m *PoolMutation) ResetCreatedBy()

+ func (m *PoolMutation) ResetDeletedAt()

+ func (m *PoolMutation) ResetDeletedBy()

+ func (m *PoolMutation) ResetUpdatedBy()

+ func (m *PoolMutation) SetCreatedBy(s string)

+ func (m *PoolMutation) SetDeletedAt(t time.Time)

+ func (m *PoolMutation) SetDeletedBy(s string)

+ func (m *PoolMutation) SetUpdatedBy(s string)

+ func (m *PoolMutation) UpdatedBy() (r string, exists bool)

+ func (m *PoolMutation) UpdatedByCleared() bool

type PoolUpdate

+ func (pu *PoolUpdate) ClearDeletedAt() *PoolUpdate

+ func (pu *PoolUpdate) ClearDeletedBy() *PoolUpdate

+ func (pu *PoolUpdate) ClearUpdatedBy() *PoolUpdate

+ func (pu *PoolUpdate) SetDeletedAt(t time.Time) *PoolUpdate

+ func (pu *PoolUpdate) SetDeletedBy(s string) *PoolUpdate

+ func (pu *PoolUpdate) SetNillableDeletedAt(t *time.Time) *PoolUpdate

+ func (pu *PoolUpdate) SetNillableDeletedBy(s *string) *PoolUpdate

+ func (pu *PoolUpdate) SetNillableUpdatedBy(s *string) *PoolUpdate

+ func (pu *PoolUpdate) SetUpdatedBy(s string) *PoolUpdate

type PoolUpdateOne

+ func (puo *PoolUpdateOne) ClearDeletedAt() *PoolUpdateOne

+ func (puo *PoolUpdateOne) ClearDeletedBy() *PoolUpdateOne

+ func (puo *PoolUpdateOne) ClearUpdatedBy() *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetDeletedAt(t time.Time) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetDeletedBy(s string) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetNillableDeletedAt(t *time.Time) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetNillableDeletedBy(s *string) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetNillableUpdatedBy(s *string) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetUpdatedBy(s string) *PoolUpdateOne

type Port

+ CreatedBy string

+ DeletedAt time.Time

+ DeletedBy string

+ UpdatedBy string

type PortCreate

+ func (pc *PortCreate) SetCreatedBy(s string) *PortCreate

+ func (pc *PortCreate) SetDeletedAt(t time.Time) *PortCreate

+ func (pc *PortCreate) SetDeletedBy(s string) *PortCreate

+ func (pc *PortCreate) SetNillableCreatedBy(s *string) *PortCreate

+ func (pc *PortCreate) SetNillableDeletedAt(t *time.Time) *PortCreate

+ func (pc *PortCreate) SetNillableDeletedBy(s *string) *PortCreate

+ func (pc *PortCreate) SetNillableUpdatedBy(s *string) *PortCreate

+ func (pc *PortCreate) SetUpdatedBy(s string) *PortCreate

type PortMutation

+ func (m *PortMutation) ClearCreatedBy()

+ func (m *PortMutation) ClearDeletedAt()

+ func (m *PortMutation) ClearDeletedBy()

+ func (m *PortMutation) ClearUpdatedBy()

+ func (m *PortMutation) CreatedBy() (r string, exists bool)

+ func (m *PortMutation) CreatedByCleared() bool

+ func (m *PortMutation) DeletedAt() (r time.Time, exists bool)

+ func (m *PortMutation) DeletedAtCleared() bool

+ func (m *PortMutation) DeletedBy() (r string, exists bool)

+ func (m *PortMutation) DeletedByCleared() bool

+ func (m *PortMutation) OldCreatedBy(ctx context.Context) (v string, err error)

+ func (m *PortMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PortMutation) OldDeletedBy(ctx context.Context) (v string, err error)

+ func (m *PortMutation) OldUpdatedBy(ctx context.Context) (v string, err error)

+ func (m *PortMutation) ResetCreatedBy()

+ func (m *PortMutation) ResetDeletedAt()

+ func (m *PortMutation) ResetDeletedBy()

+ func (m *PortMutation) ResetUpdatedBy()

+ func (m *PortMutation) SetCreatedBy(s string)

+ func (m *PortMutation) SetDeletedAt(t time.Time)

+ func (m *PortMutation) SetDeletedBy(s string)

+ func (m *PortMutation) SetUpdatedBy(s string)

+ func (m *PortMutation) UpdatedBy() (r string, exists bool)

+ func (m *PortMutation) UpdatedByCleared() bool

type PortUpdate

+ func (pu *PortUpdate) ClearDeletedAt() *PortUpdate

+ func (pu *PortUpdate) ClearDeletedBy() *PortUpdate

+ func (pu *PortUpdate) ClearUpdatedBy() *PortUpdate

+ func (pu *PortUpdate) SetDeletedAt(t time.Time) *PortUpdate

+ func (pu *PortUpdate) SetDeletedBy(s string) *PortUpdate

+ func (pu *PortUpdate) SetNillableDeletedAt(t *time.Time) *PortUpdate

+ func (pu *PortUpdate) SetNillableDeletedBy(s *string) *PortUpdate

+ func (pu *PortUpdate) SetNillableUpdatedBy(s *string) *PortUpdate

+ func (pu *PortUpdate) SetUpdatedBy(s string) *PortUpdate

type PortUpdateOne

+ func (puo *PortUpdateOne) ClearDeletedAt() *PortUpdateOne

+ func (puo *PortUpdateOne) ClearDeletedBy() *PortUpdateOne

+ func (puo *PortUpdateOne) ClearUpdatedBy() *PortUpdateOne

+ func (puo *PortUpdateOne) SetDeletedAt(t time.Time) *PortUpdateOne

+ func (puo *PortUpdateOne) SetDeletedBy(s string) *PortUpdateOne

+ func (puo *PortUpdateOne) SetNillableDeletedAt(t *time.Time) *PortUpdateOne

+ func (puo *PortUpdateOne) SetNillableDeletedBy(s *string) *PortUpdateOne

+ func (puo *PortUpdateOne) SetNillableUpdatedBy(s *string) *PortUpdateOne

+ func (puo *PortUpdateOne) SetUpdatedBy(s string) *PortUpdateOne

type Provider

+ CreatedBy string

+ DeletedAt time.Time

+ DeletedBy string

+ UpdatedBy string

type ProviderCreate

+ func (pc *ProviderCreate) SetCreatedBy(s string) *ProviderCreate

+ func (pc *ProviderCreate) SetDeletedAt(t time.Time) *ProviderCreate

+ func (pc *ProviderCreate) SetDeletedBy(s string) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableCreatedBy(s *string) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableDeletedAt(t *time.Time) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableDeletedBy(s *string) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableUpdatedBy(s *string) *ProviderCreate

+ func (pc *ProviderCreate) SetUpdatedBy(s string) *ProviderCreate

type ProviderMutation

+ func (m *ProviderMutation) ClearCreatedBy()

+ func (m *ProviderMutation) ClearDeletedAt()

+ func (m *ProviderMutation) ClearDeletedBy()

+ func (m *ProviderMutation) ClearUpdatedBy()

+ func (m *ProviderMutation) CreatedBy() (r string, exists bool)

+ func (m *ProviderMutation) CreatedByCleared() bool

+ func (m *ProviderMutation) DeletedAt() (r time.Time, exists bool)

+ func (m *ProviderMutation) DeletedAtCleared() bool

+ func (m *ProviderMutation) DeletedBy() (r string, exists bool)

+ func (m *ProviderMutation) DeletedByCleared() bool

+ func (m *ProviderMutation) OldCreatedBy(ctx context.Context) (v string, err error)

+ func (m *ProviderMutation) OldDeletedAt(ctx context.Context) (v time.Time, err error)

+ func (m *ProviderMutation) OldDeletedBy(ctx context.Context) (v string, err error)

+ func (m *ProviderMutation) OldUpdatedBy(ctx context.Context) (v string, err error)

+ func (m *ProviderMutation) ResetCreatedBy()

+ func (m *ProviderMutation) ResetDeletedAt()

+ func (m *ProviderMutation) ResetDeletedBy()

+ func (m *ProviderMutation) ResetUpdatedBy()

+ func (m *ProviderMutation) SetCreatedBy(s string)

+ func (m *ProviderMutation) SetDeletedAt(t time.Time)

+ func (m *ProviderMutation) SetDeletedBy(s string)

+ func (m *ProviderMutation) SetUpdatedBy(s string)

+ func (m *ProviderMutation) UpdatedBy() (r string, exists bool)

+ func (m *ProviderMutation) UpdatedByCleared() bool

type ProviderUpdate

+ func (pu *ProviderUpdate) ClearDeletedAt() *ProviderUpdate

+ func (pu *ProviderUpdate) ClearDeletedBy() *ProviderUpdate

+ func (pu *ProviderUpdate) ClearUpdatedBy() *ProviderUpdate

+ func (pu *ProviderUpdate) SetDeletedAt(t time.Time) *ProviderUpdate

+ func (pu *ProviderUpdate) SetDeletedBy(s string) *ProviderUpdate

+ func (pu *ProviderUpdate) SetNillableDeletedAt(t *time.Time) *ProviderUpdate

+ func (pu *ProviderUpdate) SetNillableDeletedBy(s *string) *ProviderUpdate

+ func (pu *ProviderUpdate) SetNillableUpdatedBy(s *string) *ProviderUpdate

+ func (pu *ProviderUpdate) SetUpdatedBy(s string) *ProviderUpdate

type ProviderUpdateOne

+ func (puo *ProviderUpdateOne) ClearDeletedAt() *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) ClearDeletedBy() *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) ClearUpdatedBy() *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetDeletedAt(t time.Time) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetDeletedBy(s string) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetNillableDeletedAt(t *time.Time) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetNillableDeletedBy(s *string) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetNillableUpdatedBy(s *string) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) SetUpdatedBy(s string) *ProviderUpdateOne

v0.1.3

Jan 9, 2024

v0.1.2

Dec 19, 2023

v0.1.1

Dec 18, 2023

v0.1.0

Dec 11, 2023

v0.0.35

Nov 29, 2023

v0.0.34

Nov 15, 2023

v0.0.33

Nov 3, 2023

v0.0.32

Oct 18, 2023

Changes in this version

+ var OriginOrderFieldWeight = &LoadBalancerOriginOrderField

type CreateLoadBalancerOriginInput

+ Weight *int32

type LoadBalancerOriginWhereInput

+ Weight *int32

+ WeightGT *int32

+ WeightGTE *int32

+ WeightIn []int32

+ WeightLT *int32

+ WeightLTE *int32

+ WeightNEQ *int32

+ WeightNotIn []int32

type Origin

+ Weight int32

type OriginCreate

+ func (oc *OriginCreate) SetNillableWeight(i *int32) *OriginCreate

+ func (oc *OriginCreate) SetWeight(i int32) *OriginCreate

type OriginMutation

+ func (m *OriginMutation) AddWeight(i int32)

+ func (m *OriginMutation) AddedWeight() (r int32, exists bool)

+ func (m *OriginMutation) OldWeight(ctx context.Context) (v int32, err error)

+ func (m *OriginMutation) ResetWeight()

+ func (m *OriginMutation) SetWeight(i int32)

+ func (m *OriginMutation) Weight() (r int32, exists bool)

type OriginUpdate

+ func (ou *OriginUpdate) AddWeight(i int32) *OriginUpdate

+ func (ou *OriginUpdate) SetNillableWeight(i *int32) *OriginUpdate

+ func (ou *OriginUpdate) SetWeight(i int32) *OriginUpdate

type OriginUpdateOne

+ func (ouo *OriginUpdateOne) AddWeight(i int32) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetNillableWeight(i *int32) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetWeight(i int32) *OriginUpdateOne

type UpdateLoadBalancerOriginInput

+ Weight *int32

v0.0.31

Oct 6, 2023

v0.0.30

Oct 4, 2023

v0.0.29

Oct 4, 2023

Changes in this version

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

type LoadBalancerClient

+ func (c *LoadBalancerClient) MapCreateBulk(slice any, setFunc func(*LoadBalancerCreate, int)) *LoadBalancerCreateBulk

type OriginClient

+ func (c *OriginClient) MapCreateBulk(slice any, setFunc func(*OriginCreate, int)) *OriginCreateBulk

type PoolClient

+ func (c *PoolClient) MapCreateBulk(slice any, setFunc func(*PoolCreate, int)) *PoolCreateBulk

type PortClient

+ func (c *PortClient) MapCreateBulk(slice any, setFunc func(*PortCreate, int)) *PortCreateBulk

type ProviderClient

+ func (c *ProviderClient) MapCreateBulk(slice any, setFunc func(*ProviderCreate, int)) *ProviderCreateBulk

v0.0.28

Oct 4, 2023

v0.0.27

Oct 2, 2023

Changes in this version

type LoadBalancer

+ func (lb LoadBalancer) IsMetadataNode()

+ type MetadataNode interface

+ IsMetadataNode func()

v0.0.26

Sep 8, 2023

v0.0.25

Aug 30, 2023

v0.0.24

Aug 10, 2023

v0.0.23

Jul 31, 2023

v0.0.22

Jul 11, 2023

v0.0.21

Jun 30, 2023

v0.0.20

Jun 29, 2023

Changes in this version

+ type IPAddressable interface

+ IsIPAddressable func()

type LoadBalancer

+ func (lb LoadBalancer) IsIPAddressable()

v0.0.19

Jun 26, 2023

v0.0.18

Jun 22, 2023

Changes in this version

+ var LoadBalancerOrderFieldOwnerID = &LoadBalancerOrderField

+ var ProviderOrderFieldOwnerID = &LoadBalancerProviderOrderField

type CreateLoadBalancerInput

+ OwnerID gidx.PrefixedID

type CreateLoadBalancerPoolInput

+ OwnerID gidx.PrefixedID

type CreateLoadBalancerProviderInput

+ OwnerID gidx.PrefixedID

type LoadBalancer

+ OwnerID gidx.PrefixedID

type LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetOwnerID(gi gidx.PrefixedID) *LoadBalancerCreate

type LoadBalancerMutation

+ func (m *LoadBalancerMutation) OldOwnerID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *LoadBalancerMutation) OwnerID() (r gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerMutation) ResetOwnerID()

+ func (m *LoadBalancerMutation) SetOwnerID(gi gidx.PrefixedID)

type Option

+ func EventsPublisher(v *events.Publisher) Option

type Pool

+ OwnerID gidx.PrefixedID

type PoolCreate

+ func (pc *PoolCreate) SetOwnerID(gi gidx.PrefixedID) *PoolCreate

type PoolMutation

+ func (m *PoolMutation) OldOwnerID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *PoolMutation) OwnerID() (r gidx.PrefixedID, exists bool)

+ func (m *PoolMutation) ResetOwnerID()

+ func (m *PoolMutation) SetOwnerID(gi gidx.PrefixedID)

type Provider

+ OwnerID gidx.PrefixedID

type ProviderCreate

+ func (pc *ProviderCreate) SetOwnerID(gi gidx.PrefixedID) *ProviderCreate

type ProviderMutation

+ func (m *ProviderMutation) OldOwnerID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *ProviderMutation) OwnerID() (r gidx.PrefixedID, exists bool)

+ func (m *ProviderMutation) ResetOwnerID()

+ func (m *ProviderMutation) SetOwnerID(gi gidx.PrefixedID)

v0.0.17

May 18, 2023

Changes in this version

+ const OpCreate

+ const OpDelete

+ const OpDeleteOne

+ const OpUpdate

+ const OpUpdateOne

+ const TypeLoadBalancer

+ const TypeLoadBalancerAnnotation

+ const TypeLoadBalancerStatus

+ const TypeOrigin

+ const TypePool

+ const TypePort

+ const TypeProvider

+ var DefaultLoadBalancerAnnotationOrder = &LoadBalancerAnnotationOrder

+ var DefaultLoadBalancerOrder = &LoadBalancerOrder

+ var DefaultLoadBalancerOriginOrder = &LoadBalancerOriginOrder

+ var DefaultLoadBalancerPoolOrder = &LoadBalancerPoolOrder

+ var DefaultLoadBalancerPortOrder = &LoadBalancerPortOrder

+ var DefaultLoadBalancerProviderOrder = &LoadBalancerProviderOrder

+ var DefaultLoadBalancerStatusOrder = &LoadBalancerStatusOrder

+ var ErrEmptyLoadBalancerAnnotationWhereInput = errors.New("generated: empty predicate LoadBalancerAnnotationWhereInput")

+ var ErrEmptyLoadBalancerOriginWhereInput = errors.New("generated: empty predicate LoadBalancerOriginWhereInput")

+ var ErrEmptyLoadBalancerPoolWhereInput = errors.New("generated: empty predicate LoadBalancerPoolWhereInput")

+ var ErrEmptyLoadBalancerPortWhereInput = errors.New("generated: empty predicate LoadBalancerPortWhereInput")

+ var ErrEmptyLoadBalancerProviderWhereInput = errors.New("generated: empty predicate LoadBalancerProviderWhereInput")

+ var ErrEmptyLoadBalancerStatusWhereInput = errors.New("generated: empty predicate LoadBalancerStatusWhereInput")

+ var ErrEmptyLoadBalancerWhereInput = errors.New("generated: empty predicate LoadBalancerWhereInput")

+ var LoadBalancerAnnotationOrderFieldCreatedAt = &LoadBalancerAnnotationOrderField

+ var LoadBalancerAnnotationOrderFieldNamespace = &LoadBalancerAnnotationOrderField

+ var LoadBalancerAnnotationOrderFieldUpdatedAt = &LoadBalancerAnnotationOrderField

+ var LoadBalancerOrderFieldCreatedAt = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldID = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldName = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldTenantID = &LoadBalancerOrderField

+ var LoadBalancerOrderFieldUpdatedAt = &LoadBalancerOrderField

+ var LoadBalancerStatusOrderFieldCreatedAt = &LoadBalancerStatusOrderField

+ var LoadBalancerStatusOrderFieldNamespace = &LoadBalancerStatusOrderField

+ var LoadBalancerStatusOrderFieldUpdatedAt = &LoadBalancerStatusOrderField

+ var OriginOrderFieldActive = &LoadBalancerOriginOrderField

+ var OriginOrderFieldCreatedAt = &LoadBalancerOriginOrderField

+ var OriginOrderFieldName = &LoadBalancerOriginOrderField

+ var OriginOrderFieldPortNumber = &LoadBalancerOriginOrderField

+ var OriginOrderFieldTarget = &LoadBalancerOriginOrderField

+ var OriginOrderFieldUpdatedAt = &LoadBalancerOriginOrderField

+ var PoolOrderFieldCreatedAt = &LoadBalancerPoolOrderField

+ var PoolOrderFieldName = &LoadBalancerPoolOrderField

+ var PoolOrderFieldProtocol = &LoadBalancerPoolOrderField

+ var PoolOrderFieldUpdatedAt = &LoadBalancerPoolOrderField

+ var PortOrderFieldCreatedAt = &LoadBalancerPortOrderField

+ var PortOrderFieldName = &LoadBalancerPortOrderField

+ var PortOrderFieldNumber = &LoadBalancerPortOrderField

+ var PortOrderFieldUpdatedAt = &LoadBalancerPortOrderField

+ var ProviderOrderFieldCreatedAt = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldID = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldName = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldTenantID = &LoadBalancerProviderOrderField

+ var ProviderOrderFieldUpdatedAt = &LoadBalancerProviderOrderField

+ func Asc(fields ...string) func(*sql.Selector)

+ func Desc(fields ...string) func(*sql.Selector)

+ 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 Client struct

+ LoadBalancer *LoadBalancerClient

+ LoadBalancerAnnotation *LoadBalancerAnnotationClient

+ LoadBalancerStatus *LoadBalancerStatusClient

+ Origin *OriginClient

+ Pool *PoolClient

+ Port *PortClient

+ Provider *ProviderClient

+ Schema *migrate.Schema

+ 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) Intercept(interceptors ...Interceptor)

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

+ func (c *Client) Noder(ctx context.Context, id gidx.PrefixedID, opts ...NodeOption) (_ Noder, err error)

+ func (c *Client) Noders(ctx context.Context, ids []gidx.PrefixedID, 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 CreateLoadBalancerInput struct

+ LocationID gidx.PrefixedID

+ Name string

+ PortIDs []gidx.PrefixedID

+ ProviderID gidx.PrefixedID

+ TenantID gidx.PrefixedID

+ func (i *CreateLoadBalancerInput) Mutate(m *LoadBalancerMutation)

+ type CreateLoadBalancerOriginInput struct

+ Active *bool

+ Name string

+ PoolID gidx.PrefixedID

+ PortNumber int

+ Target string

+ func (i *CreateLoadBalancerOriginInput) Mutate(m *OriginMutation)

+ type CreateLoadBalancerPoolInput struct

+ Name string

+ OriginIDs []gidx.PrefixedID

+ PortIDs []gidx.PrefixedID

+ Protocol pool.Protocol

+ TenantID gidx.PrefixedID

+ func (i *CreateLoadBalancerPoolInput) Mutate(m *PoolMutation)

+ type CreateLoadBalancerPortInput struct

+ LoadBalancerID gidx.PrefixedID

+ Name string

+ Number int

+ PoolIDs []gidx.PrefixedID

+ func (i *CreateLoadBalancerPortInput) Mutate(m *PortMutation)

+ type CreateLoadBalancerProviderInput struct

+ Name string

+ TenantID gidx.PrefixedID

+ func (i *CreateLoadBalancerProviderInput) Mutate(m *ProviderMutation)

+ type Cursor = entgql.Cursor[gidx.PrefixedID]

+ type Hook = ent.Hook

+ type IPv4Addressable interface

+ IsIPv4Addressable func()

+ type IPv6Addressable interface

+ IsIPv6Addressable func()

+ type InterceptFunc = ent.InterceptFunc

+ type Interceptor = ent.Interceptor

+ type LoadBalancer struct

+ CreatedAt time.Time

+ Edges LoadBalancerEdges

+ ID gidx.PrefixedID

+ LocationID gidx.PrefixedID

+ Name string

+ ProviderID gidx.PrefixedID

+ TenantID gidx.PrefixedID

+ UpdatedAt time.Time

+ func (lb *LoadBalancer) Annotations(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerAnnotationConnection, error)

+ func (lb *LoadBalancer) NamedAnnotations(name string) ([]*LoadBalancerAnnotation, error)

+ func (lb *LoadBalancer) NamedPorts(name string) ([]*Port, error)

+ func (lb *LoadBalancer) NamedStatuses(name string) ([]*LoadBalancerStatus, error)

+ func (lb *LoadBalancer) Ports(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerPortConnection, error)

+ func (lb *LoadBalancer) Provider(ctx context.Context) (*Provider, error)

+ func (lb *LoadBalancer) QueryAnnotations() *LoadBalancerAnnotationQuery

+ func (lb *LoadBalancer) QueryPorts() *PortQuery

+ func (lb *LoadBalancer) QueryProvider() *ProviderQuery

+ func (lb *LoadBalancer) QueryStatuses() *LoadBalancerStatusQuery

+ func (lb *LoadBalancer) Statuses(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerStatusConnection, error)

+ func (lb *LoadBalancer) String() string

+ func (lb *LoadBalancer) ToEdge(order *LoadBalancerOrder) *LoadBalancerEdge

+ func (lb *LoadBalancer) Unwrap() *LoadBalancer

+ func (lb *LoadBalancer) Update() *LoadBalancerUpdateOne

+ func (lb *LoadBalancer) Value(name string) (ent.Value, error)

+ func (lb LoadBalancer) IsEntity()

+ func (lb LoadBalancer) IsIPv4Addressable()

+ func (n *LoadBalancer) IsNode()

+ type LoadBalancerAnnotation struct

+ CreatedAt time.Time

+ Data json.RawMessage

+ Edges LoadBalancerAnnotationEdges

+ ID gidx.PrefixedID

+ LoadBalancerID gidx.PrefixedID

+ Namespace string

+ UpdatedAt time.Time

+ func (lba *LoadBalancerAnnotation) LoadBalancer(ctx context.Context) (*LoadBalancer, error)

+ func (lba *LoadBalancerAnnotation) QueryLoadBalancer() *LoadBalancerQuery

+ func (lba *LoadBalancerAnnotation) String() string

+ func (lba *LoadBalancerAnnotation) ToEdge(order *LoadBalancerAnnotationOrder) *LoadBalancerAnnotationEdge

+ func (lba *LoadBalancerAnnotation) Unwrap() *LoadBalancerAnnotation

+ func (lba *LoadBalancerAnnotation) Update() *LoadBalancerAnnotationUpdateOne

+ func (lba *LoadBalancerAnnotation) Value(name string) (ent.Value, error)

+ func (lba LoadBalancerAnnotation) IsEntity()

+ func (n *LoadBalancerAnnotation) IsNode()

+ type LoadBalancerAnnotationClient struct

+ func NewLoadBalancerAnnotationClient(c config) *LoadBalancerAnnotationClient

+ func (c *LoadBalancerAnnotationClient) Create() *LoadBalancerAnnotationCreate

+ func (c *LoadBalancerAnnotationClient) CreateBulk(builders ...*LoadBalancerAnnotationCreate) *LoadBalancerAnnotationCreateBulk

+ func (c *LoadBalancerAnnotationClient) Delete() *LoadBalancerAnnotationDelete

+ func (c *LoadBalancerAnnotationClient) DeleteOne(lba *LoadBalancerAnnotation) *LoadBalancerAnnotationDeleteOne

+ func (c *LoadBalancerAnnotationClient) DeleteOneID(id gidx.PrefixedID) *LoadBalancerAnnotationDeleteOne

+ func (c *LoadBalancerAnnotationClient) Get(ctx context.Context, id gidx.PrefixedID) (*LoadBalancerAnnotation, error)

+ func (c *LoadBalancerAnnotationClient) GetX(ctx context.Context, id gidx.PrefixedID) *LoadBalancerAnnotation

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

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

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

+ func (c *LoadBalancerAnnotationClient) Query() *LoadBalancerAnnotationQuery

+ func (c *LoadBalancerAnnotationClient) QueryLoadBalancer(lba *LoadBalancerAnnotation) *LoadBalancerQuery

+ func (c *LoadBalancerAnnotationClient) Update() *LoadBalancerAnnotationUpdate

+ func (c *LoadBalancerAnnotationClient) UpdateOne(lba *LoadBalancerAnnotation) *LoadBalancerAnnotationUpdateOne

+ func (c *LoadBalancerAnnotationClient) UpdateOneID(id gidx.PrefixedID) *LoadBalancerAnnotationUpdateOne

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

+ type LoadBalancerAnnotationConnection struct

+ Edges []*LoadBalancerAnnotationEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerAnnotationCreate struct

+ func (lbac *LoadBalancerAnnotationCreate) Exec(ctx context.Context) error

+ func (lbac *LoadBalancerAnnotationCreate) ExecX(ctx context.Context)

+ func (lbac *LoadBalancerAnnotationCreate) Mutation() *LoadBalancerAnnotationMutation

+ func (lbac *LoadBalancerAnnotationCreate) Save(ctx context.Context) (*LoadBalancerAnnotation, error)

+ func (lbac *LoadBalancerAnnotationCreate) SaveX(ctx context.Context) *LoadBalancerAnnotation

+ func (lbac *LoadBalancerAnnotationCreate) SetCreatedAt(t time.Time) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetData(jm json.RawMessage) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetID(gi gidx.PrefixedID) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetLoadBalancer(l *LoadBalancer) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetLoadBalancerID(gi gidx.PrefixedID) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetNamespace(s string) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetNillableCreatedAt(t *time.Time) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetNillableID(gi *gidx.PrefixedID) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetNillableUpdatedAt(t *time.Time) *LoadBalancerAnnotationCreate

+ func (lbac *LoadBalancerAnnotationCreate) SetUpdatedAt(t time.Time) *LoadBalancerAnnotationCreate

+ type LoadBalancerAnnotationCreateBulk struct

+ func (lbacb *LoadBalancerAnnotationCreateBulk) Exec(ctx context.Context) error

+ func (lbacb *LoadBalancerAnnotationCreateBulk) ExecX(ctx context.Context)

+ func (lbacb *LoadBalancerAnnotationCreateBulk) Save(ctx context.Context) ([]*LoadBalancerAnnotation, error)

+ func (lbacb *LoadBalancerAnnotationCreateBulk) SaveX(ctx context.Context) []*LoadBalancerAnnotation

+ type LoadBalancerAnnotationDelete struct

+ func (lbad *LoadBalancerAnnotationDelete) Exec(ctx context.Context) (int, error)

+ func (lbad *LoadBalancerAnnotationDelete) ExecX(ctx context.Context) int

+ func (lbad *LoadBalancerAnnotationDelete) Where(ps ...predicate.LoadBalancerAnnotation) *LoadBalancerAnnotationDelete

+ type LoadBalancerAnnotationDeleteOne struct

+ func (lbado *LoadBalancerAnnotationDeleteOne) Exec(ctx context.Context) error

+ func (lbado *LoadBalancerAnnotationDeleteOne) ExecX(ctx context.Context)

+ func (lbado *LoadBalancerAnnotationDeleteOne) Where(ps ...predicate.LoadBalancerAnnotation) *LoadBalancerAnnotationDeleteOne

+ type LoadBalancerAnnotationEdge struct

+ Cursor Cursor

+ Node *LoadBalancerAnnotation

+ type LoadBalancerAnnotationEdges struct

+ LoadBalancer *LoadBalancer

+ func (e LoadBalancerAnnotationEdges) LoadBalancerOrErr() (*LoadBalancer, error)

+ type LoadBalancerAnnotationGroupBy struct

+ func (lbagb *LoadBalancerAnnotationGroupBy) Aggregate(fns ...AggregateFunc) *LoadBalancerAnnotationGroupBy

+ func (lbagb *LoadBalancerAnnotationGroupBy) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerAnnotationMutation struct

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

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

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

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

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

+ func (m *LoadBalancerAnnotationMutation) AppendData(jm json.RawMessage)

+ func (m *LoadBalancerAnnotationMutation) AppendedData() (json.RawMessage, bool)

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

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

+ func (m *LoadBalancerAnnotationMutation) ClearLoadBalancer()

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

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

+ func (m *LoadBalancerAnnotationMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerAnnotationMutation) Data() (r json.RawMessage, exists bool)

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

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

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

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

+ func (m *LoadBalancerAnnotationMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerAnnotationMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

+ func (m *LoadBalancerAnnotationMutation) LoadBalancerCleared() bool

+ func (m *LoadBalancerAnnotationMutation) LoadBalancerID() (r gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerAnnotationMutation) LoadBalancerIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerAnnotationMutation) Namespace() (r string, exists bool)

+ func (m *LoadBalancerAnnotationMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerAnnotationMutation) OldData(ctx context.Context) (v json.RawMessage, err error)

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

+ func (m *LoadBalancerAnnotationMutation) OldLoadBalancerID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *LoadBalancerAnnotationMutation) OldNamespace(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerAnnotationMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerAnnotationMutation) Op() Op

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

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

+ func (m *LoadBalancerAnnotationMutation) ResetCreatedAt()

+ func (m *LoadBalancerAnnotationMutation) ResetData()

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

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

+ func (m *LoadBalancerAnnotationMutation) ResetLoadBalancer()

+ func (m *LoadBalancerAnnotationMutation) ResetLoadBalancerID()

+ func (m *LoadBalancerAnnotationMutation) ResetNamespace()

+ func (m *LoadBalancerAnnotationMutation) ResetUpdatedAt()

+ func (m *LoadBalancerAnnotationMutation) SetCreatedAt(t time.Time)

+ func (m *LoadBalancerAnnotationMutation) SetData(jm json.RawMessage)

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

+ func (m *LoadBalancerAnnotationMutation) SetID(id gidx.PrefixedID)

+ func (m *LoadBalancerAnnotationMutation) SetLoadBalancerID(gi gidx.PrefixedID)

+ func (m *LoadBalancerAnnotationMutation) SetNamespace(s string)

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

+ func (m *LoadBalancerAnnotationMutation) SetUpdatedAt(t time.Time)

+ func (m *LoadBalancerAnnotationMutation) Type() string

+ func (m *LoadBalancerAnnotationMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerAnnotationMutation) Where(ps ...predicate.LoadBalancerAnnotation)

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

+ func (m LoadBalancerAnnotationMutation) Client() *Client

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

+ type LoadBalancerAnnotationOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerAnnotationOrderField

+ type LoadBalancerAnnotationOrderField struct

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

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

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

+ func (f LoadBalancerAnnotationOrderField) String() string

+ type LoadBalancerAnnotationPaginateOption func(*loadbalancerannotationPager) error

+ func WithLoadBalancerAnnotationFilter(...) LoadBalancerAnnotationPaginateOption

+ func WithLoadBalancerAnnotationOrder(order *LoadBalancerAnnotationOrder) LoadBalancerAnnotationPaginateOption

+ type LoadBalancerAnnotationQuery struct

+ func (lba *LoadBalancerAnnotationQuery) CollectFields(ctx context.Context, satisfies ...string) (*LoadBalancerAnnotationQuery, error)

+ func (lba *LoadBalancerAnnotationQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerAnnotationConnection, error)

+ func (lbaq *LoadBalancerAnnotationQuery) Aggregate(fns ...AggregateFunc) *LoadBalancerAnnotationSelect

+ func (lbaq *LoadBalancerAnnotationQuery) All(ctx context.Context) ([]*LoadBalancerAnnotation, error)

+ func (lbaq *LoadBalancerAnnotationQuery) AllX(ctx context.Context) []*LoadBalancerAnnotation

+ func (lbaq *LoadBalancerAnnotationQuery) Clone() *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) Count(ctx context.Context) (int, error)

+ func (lbaq *LoadBalancerAnnotationQuery) CountX(ctx context.Context) int

+ func (lbaq *LoadBalancerAnnotationQuery) Exist(ctx context.Context) (bool, error)

+ func (lbaq *LoadBalancerAnnotationQuery) ExistX(ctx context.Context) bool

+ func (lbaq *LoadBalancerAnnotationQuery) First(ctx context.Context) (*LoadBalancerAnnotation, error)

+ func (lbaq *LoadBalancerAnnotationQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbaq *LoadBalancerAnnotationQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (lbaq *LoadBalancerAnnotationQuery) FirstX(ctx context.Context) *LoadBalancerAnnotation

+ func (lbaq *LoadBalancerAnnotationQuery) GroupBy(field string, fields ...string) *LoadBalancerAnnotationGroupBy

+ func (lbaq *LoadBalancerAnnotationQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (lbaq *LoadBalancerAnnotationQuery) IDsX(ctx context.Context) []gidx.PrefixedID

+ func (lbaq *LoadBalancerAnnotationQuery) Limit(limit int) *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) Offset(offset int) *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) Only(ctx context.Context) (*LoadBalancerAnnotation, error)

+ func (lbaq *LoadBalancerAnnotationQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbaq *LoadBalancerAnnotationQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (lbaq *LoadBalancerAnnotationQuery) OnlyX(ctx context.Context) *LoadBalancerAnnotation

+ func (lbaq *LoadBalancerAnnotationQuery) Order(o ...loadbalancerannotation.OrderOption) *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) QueryLoadBalancer() *LoadBalancerQuery

+ func (lbaq *LoadBalancerAnnotationQuery) Select(fields ...string) *LoadBalancerAnnotationSelect

+ func (lbaq *LoadBalancerAnnotationQuery) Unique(unique bool) *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) Where(ps ...predicate.LoadBalancerAnnotation) *LoadBalancerAnnotationQuery

+ func (lbaq *LoadBalancerAnnotationQuery) WithLoadBalancer(opts ...func(*LoadBalancerQuery)) *LoadBalancerAnnotationQuery

+ type LoadBalancerAnnotationSelect struct

+ func (lbas *LoadBalancerAnnotationSelect) Aggregate(fns ...AggregateFunc) *LoadBalancerAnnotationSelect

+ func (lbas *LoadBalancerAnnotationSelect) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerAnnotationUpdate struct

+ func (lbau *LoadBalancerAnnotationUpdate) AppendData(jm json.RawMessage) *LoadBalancerAnnotationUpdate

+ func (lbau *LoadBalancerAnnotationUpdate) Exec(ctx context.Context) error

+ func (lbau *LoadBalancerAnnotationUpdate) ExecX(ctx context.Context)

+ func (lbau *LoadBalancerAnnotationUpdate) Mutation() *LoadBalancerAnnotationMutation

+ func (lbau *LoadBalancerAnnotationUpdate) Save(ctx context.Context) (int, error)

+ func (lbau *LoadBalancerAnnotationUpdate) SaveX(ctx context.Context) int

+ func (lbau *LoadBalancerAnnotationUpdate) SetData(jm json.RawMessage) *LoadBalancerAnnotationUpdate

+ func (lbau *LoadBalancerAnnotationUpdate) SetNamespace(s string) *LoadBalancerAnnotationUpdate

+ func (lbau *LoadBalancerAnnotationUpdate) Where(ps ...predicate.LoadBalancerAnnotation) *LoadBalancerAnnotationUpdate

+ type LoadBalancerAnnotationUpdateOne struct

+ func (lbauo *LoadBalancerAnnotationUpdateOne) AppendData(jm json.RawMessage) *LoadBalancerAnnotationUpdateOne

+ func (lbauo *LoadBalancerAnnotationUpdateOne) Exec(ctx context.Context) error

+ func (lbauo *LoadBalancerAnnotationUpdateOne) ExecX(ctx context.Context)

+ func (lbauo *LoadBalancerAnnotationUpdateOne) Mutation() *LoadBalancerAnnotationMutation

+ func (lbauo *LoadBalancerAnnotationUpdateOne) Save(ctx context.Context) (*LoadBalancerAnnotation, error)

+ func (lbauo *LoadBalancerAnnotationUpdateOne) SaveX(ctx context.Context) *LoadBalancerAnnotation

+ func (lbauo *LoadBalancerAnnotationUpdateOne) Select(field string, fields ...string) *LoadBalancerAnnotationUpdateOne

+ func (lbauo *LoadBalancerAnnotationUpdateOne) SetData(jm json.RawMessage) *LoadBalancerAnnotationUpdateOne

+ func (lbauo *LoadBalancerAnnotationUpdateOne) SetNamespace(s string) *LoadBalancerAnnotationUpdateOne

+ func (lbauo *LoadBalancerAnnotationUpdateOne) Where(ps ...predicate.LoadBalancerAnnotation) *LoadBalancerAnnotationUpdateOne

+ type LoadBalancerAnnotationWhereInput struct

+ And []*LoadBalancerAnnotationWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasLoadBalancer *bool

+ HasLoadBalancerWith []*LoadBalancerWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ Namespace *string

+ NamespaceContains *string

+ NamespaceContainsFold *string

+ NamespaceEqualFold *string

+ NamespaceGT *string

+ NamespaceGTE *string

+ NamespaceHasPrefix *string

+ NamespaceHasSuffix *string

+ NamespaceIn []string

+ NamespaceLT *string

+ NamespaceLTE *string

+ NamespaceNEQ *string

+ NamespaceNotIn []string

+ Not *LoadBalancerAnnotationWhereInput

+ Or []*LoadBalancerAnnotationWhereInput

+ Predicates []predicate.LoadBalancerAnnotation

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerAnnotationWhereInput) AddPredicates(predicates ...predicate.LoadBalancerAnnotation)

+ func (i *LoadBalancerAnnotationWhereInput) Filter(q *LoadBalancerAnnotationQuery) (*LoadBalancerAnnotationQuery, error)

+ func (i *LoadBalancerAnnotationWhereInput) P() (predicate.LoadBalancerAnnotation, error)

+ type LoadBalancerAnnotations []*LoadBalancerAnnotation

+ type LoadBalancerClient struct

+ func NewLoadBalancerClient(c config) *LoadBalancerClient

+ func (c *LoadBalancerClient) Create() *LoadBalancerCreate

+ func (c *LoadBalancerClient) CreateBulk(builders ...*LoadBalancerCreate) *LoadBalancerCreateBulk

+ func (c *LoadBalancerClient) Delete() *LoadBalancerDelete

+ func (c *LoadBalancerClient) DeleteOne(lb *LoadBalancer) *LoadBalancerDeleteOne

+ func (c *LoadBalancerClient) DeleteOneID(id gidx.PrefixedID) *LoadBalancerDeleteOne

+ func (c *LoadBalancerClient) Get(ctx context.Context, id gidx.PrefixedID) (*LoadBalancer, error)

+ func (c *LoadBalancerClient) GetX(ctx context.Context, id gidx.PrefixedID) *LoadBalancer

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

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

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

+ func (c *LoadBalancerClient) Query() *LoadBalancerQuery

+ func (c *LoadBalancerClient) QueryAnnotations(lb *LoadBalancer) *LoadBalancerAnnotationQuery

+ func (c *LoadBalancerClient) QueryPorts(lb *LoadBalancer) *PortQuery

+ func (c *LoadBalancerClient) QueryProvider(lb *LoadBalancer) *ProviderQuery

+ func (c *LoadBalancerClient) QueryStatuses(lb *LoadBalancer) *LoadBalancerStatusQuery

+ func (c *LoadBalancerClient) Update() *LoadBalancerUpdate

+ func (c *LoadBalancerClient) UpdateOne(lb *LoadBalancer) *LoadBalancerUpdateOne

+ func (c *LoadBalancerClient) UpdateOneID(id gidx.PrefixedID) *LoadBalancerUpdateOne

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

+ type LoadBalancerConnection struct

+ Edges []*LoadBalancerEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerCreate struct

+ func (c *LoadBalancerCreate) SetInput(i CreateLoadBalancerInput) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddAnnotationIDs(ids ...gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddAnnotations(l ...*LoadBalancerAnnotation) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddPortIDs(ids ...gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddPorts(p ...*Port) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddStatusIDs(ids ...gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) AddStatuses(l ...*LoadBalancerStatus) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) Exec(ctx context.Context) error

+ func (lbc *LoadBalancerCreate) ExecX(ctx context.Context)

+ func (lbc *LoadBalancerCreate) Mutation() *LoadBalancerMutation

+ func (lbc *LoadBalancerCreate) Save(ctx context.Context) (*LoadBalancer, error)

+ func (lbc *LoadBalancerCreate) SaveX(ctx context.Context) *LoadBalancer

+ func (lbc *LoadBalancerCreate) SetCreatedAt(t time.Time) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetID(gi gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetLocationID(gi gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetName(s string) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableCreatedAt(t *time.Time) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableID(gi *gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetNillableUpdatedAt(t *time.Time) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetProvider(p *Provider) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetProviderID(gi gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetTenantID(gi gidx.PrefixedID) *LoadBalancerCreate

+ func (lbc *LoadBalancerCreate) SetUpdatedAt(t time.Time) *LoadBalancerCreate

+ type LoadBalancerCreateBulk struct

+ func (lbcb *LoadBalancerCreateBulk) Exec(ctx context.Context) error

+ func (lbcb *LoadBalancerCreateBulk) ExecX(ctx context.Context)

+ func (lbcb *LoadBalancerCreateBulk) Save(ctx context.Context) ([]*LoadBalancer, error)

+ func (lbcb *LoadBalancerCreateBulk) SaveX(ctx context.Context) []*LoadBalancer

+ type LoadBalancerDelete struct

+ func (lbd *LoadBalancerDelete) Exec(ctx context.Context) (int, error)

+ func (lbd *LoadBalancerDelete) ExecX(ctx context.Context) int

+ func (lbd *LoadBalancerDelete) Where(ps ...predicate.LoadBalancer) *LoadBalancerDelete

+ type LoadBalancerDeleteOne struct

+ func (lbdo *LoadBalancerDeleteOne) Exec(ctx context.Context) error

+ func (lbdo *LoadBalancerDeleteOne) ExecX(ctx context.Context)

+ func (lbdo *LoadBalancerDeleteOne) Where(ps ...predicate.LoadBalancer) *LoadBalancerDeleteOne

+ type LoadBalancerEdge struct

+ Cursor Cursor

+ Node *LoadBalancer

+ type LoadBalancerEdges struct

+ Annotations []*LoadBalancerAnnotation

+ Ports []*Port

+ Provider *Provider

+ Statuses []*LoadBalancerStatus

+ func (e LoadBalancerEdges) AnnotationsOrErr() ([]*LoadBalancerAnnotation, error)

+ func (e LoadBalancerEdges) PortsOrErr() ([]*Port, error)

+ func (e LoadBalancerEdges) ProviderOrErr() (*Provider, error)

+ func (e LoadBalancerEdges) StatusesOrErr() ([]*LoadBalancerStatus, error)

+ type LoadBalancerGroupBy struct

+ func (lbgb *LoadBalancerGroupBy) Aggregate(fns ...AggregateFunc) *LoadBalancerGroupBy

+ func (lbgb *LoadBalancerGroupBy) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerMutation struct

+ func (m *LoadBalancerMutation) AddAnnotationIDs(ids ...gidx.PrefixedID)

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

+ func (m *LoadBalancerMutation) AddPortIDs(ids ...gidx.PrefixedID)

+ func (m *LoadBalancerMutation) AddStatusIDs(ids ...gidx.PrefixedID)

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

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

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

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

+ func (m *LoadBalancerMutation) AnnotationsCleared() bool

+ func (m *LoadBalancerMutation) AnnotationsIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) ClearAnnotations()

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

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

+ func (m *LoadBalancerMutation) ClearPorts()

+ func (m *LoadBalancerMutation) ClearProvider()

+ func (m *LoadBalancerMutation) ClearStatuses()

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

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

+ func (m *LoadBalancerMutation) CreatedAt() (r time.Time, exists bool)

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

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

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

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

+ func (m *LoadBalancerMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

+ func (m *LoadBalancerMutation) LocationID() (r gidx.PrefixedID, exists bool)

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

+ func (m *LoadBalancerMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

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

+ func (m *LoadBalancerMutation) OldLocationID(ctx context.Context) (v gidx.PrefixedID, err error)

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

+ func (m *LoadBalancerMutation) OldProviderID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *LoadBalancerMutation) OldTenantID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *LoadBalancerMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerMutation) Op() Op

+ func (m *LoadBalancerMutation) PortsCleared() bool

+ func (m *LoadBalancerMutation) PortsIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) ProviderCleared() bool

+ func (m *LoadBalancerMutation) ProviderID() (r gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerMutation) ProviderIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) RemoveAnnotationIDs(ids ...gidx.PrefixedID)

+ func (m *LoadBalancerMutation) RemovePortIDs(ids ...gidx.PrefixedID)

+ func (m *LoadBalancerMutation) RemoveStatusIDs(ids ...gidx.PrefixedID)

+ func (m *LoadBalancerMutation) RemovedAnnotationsIDs() (ids []gidx.PrefixedID)

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

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

+ func (m *LoadBalancerMutation) RemovedPortsIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) RemovedStatusesIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) ResetAnnotations()

+ func (m *LoadBalancerMutation) ResetCreatedAt()

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

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

+ func (m *LoadBalancerMutation) ResetLocationID()

+ func (m *LoadBalancerMutation) ResetName()

+ func (m *LoadBalancerMutation) ResetPorts()

+ func (m *LoadBalancerMutation) ResetProvider()

+ func (m *LoadBalancerMutation) ResetProviderID()

+ func (m *LoadBalancerMutation) ResetStatuses()

+ func (m *LoadBalancerMutation) ResetTenantID()

+ func (m *LoadBalancerMutation) ResetUpdatedAt()

+ func (m *LoadBalancerMutation) SetCreatedAt(t time.Time)

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

+ func (m *LoadBalancerMutation) SetID(id gidx.PrefixedID)

+ func (m *LoadBalancerMutation) SetLocationID(gi gidx.PrefixedID)

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

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

+ func (m *LoadBalancerMutation) SetProviderID(gi gidx.PrefixedID)

+ func (m *LoadBalancerMutation) SetTenantID(gi gidx.PrefixedID)

+ func (m *LoadBalancerMutation) SetUpdatedAt(t time.Time)

+ func (m *LoadBalancerMutation) StatusesCleared() bool

+ func (m *LoadBalancerMutation) StatusesIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerMutation) TenantID() (r gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerMutation) Type() string

+ func (m *LoadBalancerMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerMutation) Where(ps ...predicate.LoadBalancer)

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

+ func (m LoadBalancerMutation) Client() *Client

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

+ type LoadBalancerOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerOrderField

+ type LoadBalancerOrderField struct

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

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

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

+ func (f LoadBalancerOrderField) String() string

+ type LoadBalancerOrigin = Origin

+ func (o *LoadBalancerOrigin) ToEdge(order *LoadBalancerOriginOrder) *LoadBalancerOriginEdge

+ type LoadBalancerOriginConnection struct

+ Edges []*LoadBalancerOriginEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerOriginEdge struct

+ Cursor Cursor

+ Node *LoadBalancerOrigin

+ type LoadBalancerOriginOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerOriginOrderField

+ type LoadBalancerOriginOrderField struct

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

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

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

+ func (f LoadBalancerOriginOrderField) String() string

+ type LoadBalancerOriginPaginateOption func(*loadbalanceroriginPager) error

+ func WithLoadBalancerOriginFilter(filter func(*OriginQuery) (*OriginQuery, error)) LoadBalancerOriginPaginateOption

+ func WithLoadBalancerOriginOrder(order *LoadBalancerOriginOrder) LoadBalancerOriginPaginateOption

+ type LoadBalancerOriginWhereInput struct

+ Active *bool

+ ActiveNEQ *bool

+ And []*LoadBalancerOriginWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasPool *bool

+ HasPoolWith []*LoadBalancerPoolWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ 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 *LoadBalancerOriginWhereInput

+ Or []*LoadBalancerOriginWhereInput

+ PortNumber *int

+ PortNumberGT *int

+ PortNumberGTE *int

+ PortNumberIn []int

+ PortNumberLT *int

+ PortNumberLTE *int

+ PortNumberNEQ *int

+ PortNumberNotIn []int

+ Predicates []predicate.Origin

+ Target *string

+ TargetContains *string

+ TargetContainsFold *string

+ TargetEqualFold *string

+ TargetGT *string

+ TargetGTE *string

+ TargetHasPrefix *string

+ TargetHasSuffix *string

+ TargetIn []string

+ TargetLT *string

+ TargetLTE *string

+ TargetNEQ *string

+ TargetNotIn []string

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerOriginWhereInput) AddPredicates(predicates ...predicate.Origin)

+ func (i *LoadBalancerOriginWhereInput) Filter(q *OriginQuery) (*OriginQuery, error)

+ func (i *LoadBalancerOriginWhereInput) P() (predicate.Origin, error)

+ type LoadBalancerPaginateOption func(*loadbalancerPager) error

+ func WithLoadBalancerFilter(filter func(*LoadBalancerQuery) (*LoadBalancerQuery, error)) LoadBalancerPaginateOption

+ func WithLoadBalancerOrder(order *LoadBalancerOrder) LoadBalancerPaginateOption

+ type LoadBalancerPool = Pool

+ func (po *LoadBalancerPool) ToEdge(order *LoadBalancerPoolOrder) *LoadBalancerPoolEdge

+ type LoadBalancerPoolConnection struct

+ Edges []*LoadBalancerPoolEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerPoolEdge struct

+ Cursor Cursor

+ Node *LoadBalancerPool

+ type LoadBalancerPoolOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerPoolOrderField

+ type LoadBalancerPoolOrderField struct

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

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

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

+ func (f LoadBalancerPoolOrderField) String() string

+ type LoadBalancerPoolPaginateOption func(*loadbalancerpoolPager) error

+ func WithLoadBalancerPoolFilter(filter func(*PoolQuery) (*PoolQuery, error)) LoadBalancerPoolPaginateOption

+ func WithLoadBalancerPoolOrder(order *LoadBalancerPoolOrder) LoadBalancerPoolPaginateOption

+ type LoadBalancerPoolWhereInput struct

+ And []*LoadBalancerPoolWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasOrigins *bool

+ HasOriginsWith []*LoadBalancerOriginWhereInput

+ HasPorts *bool

+ HasPortsWith []*LoadBalancerPortWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ 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 *LoadBalancerPoolWhereInput

+ Or []*LoadBalancerPoolWhereInput

+ Predicates []predicate.Pool

+ Protocol *pool.Protocol

+ ProtocolIn []pool.Protocol

+ ProtocolNEQ *pool.Protocol

+ ProtocolNotIn []pool.Protocol

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerPoolWhereInput) AddPredicates(predicates ...predicate.Pool)

+ func (i *LoadBalancerPoolWhereInput) Filter(q *PoolQuery) (*PoolQuery, error)

+ func (i *LoadBalancerPoolWhereInput) P() (predicate.Pool, error)

+ type LoadBalancerPort = Port

+ func (po *LoadBalancerPort) ToEdge(order *LoadBalancerPortOrder) *LoadBalancerPortEdge

+ type LoadBalancerPortConnection struct

+ Edges []*LoadBalancerPortEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerPortEdge struct

+ Cursor Cursor

+ Node *LoadBalancerPort

+ type LoadBalancerPortOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerPortOrderField

+ type LoadBalancerPortOrderField struct

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

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

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

+ func (f LoadBalancerPortOrderField) String() string

+ type LoadBalancerPortPaginateOption func(*loadbalancerportPager) error

+ func WithLoadBalancerPortFilter(filter func(*PortQuery) (*PortQuery, error)) LoadBalancerPortPaginateOption

+ func WithLoadBalancerPortOrder(order *LoadBalancerPortOrder) LoadBalancerPortPaginateOption

+ type LoadBalancerPortWhereInput struct

+ And []*LoadBalancerPortWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasLoadBalancer *bool

+ HasLoadBalancerWith []*LoadBalancerWhereInput

+ HasPools *bool

+ HasPoolsWith []*LoadBalancerPoolWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ 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 *LoadBalancerPortWhereInput

+ Number *int

+ NumberGT *int

+ NumberGTE *int

+ NumberIn []int

+ NumberLT *int

+ NumberLTE *int

+ NumberNEQ *int

+ NumberNotIn []int

+ Or []*LoadBalancerPortWhereInput

+ Predicates []predicate.Port

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerPortWhereInput) AddPredicates(predicates ...predicate.Port)

+ func (i *LoadBalancerPortWhereInput) Filter(q *PortQuery) (*PortQuery, error)

+ func (i *LoadBalancerPortWhereInput) P() (predicate.Port, error)

+ type LoadBalancerProvider = Provider

+ func (pr *LoadBalancerProvider) ToEdge(order *LoadBalancerProviderOrder) *LoadBalancerProviderEdge

+ type LoadBalancerProviderConnection struct

+ Edges []*LoadBalancerProviderEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerProviderEdge struct

+ Cursor Cursor

+ Node *LoadBalancerProvider

+ type LoadBalancerProviderOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerProviderOrderField

+ type LoadBalancerProviderOrderField struct

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

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

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

+ func (f LoadBalancerProviderOrderField) String() string

+ type LoadBalancerProviderPaginateOption func(*loadbalancerproviderPager) error

+ func WithLoadBalancerProviderFilter(filter func(*ProviderQuery) (*ProviderQuery, error)) LoadBalancerProviderPaginateOption

+ func WithLoadBalancerProviderOrder(order *LoadBalancerProviderOrder) LoadBalancerProviderPaginateOption

+ type LoadBalancerProviderWhereInput struct

+ And []*LoadBalancerProviderWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasLoadBalancers *bool

+ HasLoadBalancersWith []*LoadBalancerWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ 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 *LoadBalancerProviderWhereInput

+ Or []*LoadBalancerProviderWhereInput

+ Predicates []predicate.Provider

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerProviderWhereInput) AddPredicates(predicates ...predicate.Provider)

+ func (i *LoadBalancerProviderWhereInput) Filter(q *ProviderQuery) (*ProviderQuery, error)

+ func (i *LoadBalancerProviderWhereInput) P() (predicate.Provider, error)

+ type LoadBalancerQuery struct

+ func (lb *LoadBalancerQuery) CollectFields(ctx context.Context, satisfies ...string) (*LoadBalancerQuery, error)

+ func (lb *LoadBalancerQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerConnection, error)

+ func (lbq *LoadBalancerQuery) Aggregate(fns ...AggregateFunc) *LoadBalancerSelect

+ func (lbq *LoadBalancerQuery) All(ctx context.Context) ([]*LoadBalancer, error)

+ func (lbq *LoadBalancerQuery) AllX(ctx context.Context) []*LoadBalancer

+ func (lbq *LoadBalancerQuery) Clone() *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) Count(ctx context.Context) (int, error)

+ func (lbq *LoadBalancerQuery) CountX(ctx context.Context) int

+ func (lbq *LoadBalancerQuery) Exist(ctx context.Context) (bool, error)

+ func (lbq *LoadBalancerQuery) ExistX(ctx context.Context) bool

+ func (lbq *LoadBalancerQuery) First(ctx context.Context) (*LoadBalancer, error)

+ func (lbq *LoadBalancerQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbq *LoadBalancerQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (lbq *LoadBalancerQuery) FirstX(ctx context.Context) *LoadBalancer

+ func (lbq *LoadBalancerQuery) GroupBy(field string, fields ...string) *LoadBalancerGroupBy

+ func (lbq *LoadBalancerQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (lbq *LoadBalancerQuery) IDsX(ctx context.Context) []gidx.PrefixedID

+ func (lbq *LoadBalancerQuery) Limit(limit int) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) Offset(offset int) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) Only(ctx context.Context) (*LoadBalancer, error)

+ func (lbq *LoadBalancerQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbq *LoadBalancerQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (lbq *LoadBalancerQuery) OnlyX(ctx context.Context) *LoadBalancer

+ func (lbq *LoadBalancerQuery) Order(o ...loadbalancer.OrderOption) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) QueryAnnotations() *LoadBalancerAnnotationQuery

+ func (lbq *LoadBalancerQuery) QueryPorts() *PortQuery

+ func (lbq *LoadBalancerQuery) QueryProvider() *ProviderQuery

+ func (lbq *LoadBalancerQuery) QueryStatuses() *LoadBalancerStatusQuery

+ func (lbq *LoadBalancerQuery) Select(fields ...string) *LoadBalancerSelect

+ func (lbq *LoadBalancerQuery) Unique(unique bool) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) Where(ps ...predicate.LoadBalancer) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithAnnotations(opts ...func(*LoadBalancerAnnotationQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithNamedAnnotations(name string, opts ...func(*LoadBalancerAnnotationQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithNamedPorts(name string, opts ...func(*PortQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithNamedStatuses(name string, opts ...func(*LoadBalancerStatusQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithPorts(opts ...func(*PortQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithProvider(opts ...func(*ProviderQuery)) *LoadBalancerQuery

+ func (lbq *LoadBalancerQuery) WithStatuses(opts ...func(*LoadBalancerStatusQuery)) *LoadBalancerQuery

+ type LoadBalancerSelect struct

+ func (lbs *LoadBalancerSelect) Aggregate(fns ...AggregateFunc) *LoadBalancerSelect

+ func (lbs *LoadBalancerSelect) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerStatus struct

+ CreatedAt time.Time

+ Data json.RawMessage

+ Edges LoadBalancerStatusEdges

+ ID gidx.PrefixedID

+ LoadBalancerID gidx.PrefixedID

+ Namespace string

+ Source string

+ UpdatedAt time.Time

+ func (lbs *LoadBalancerStatus) LoadBalancer(ctx context.Context) (*LoadBalancer, error)

+ func (lbs *LoadBalancerStatus) QueryLoadBalancer() *LoadBalancerQuery

+ func (lbs *LoadBalancerStatus) String() string

+ func (lbs *LoadBalancerStatus) ToEdge(order *LoadBalancerStatusOrder) *LoadBalancerStatusEdge

+ func (lbs *LoadBalancerStatus) Unwrap() *LoadBalancerStatus

+ func (lbs *LoadBalancerStatus) Update() *LoadBalancerStatusUpdateOne

+ func (lbs *LoadBalancerStatus) Value(name string) (ent.Value, error)

+ func (lbs LoadBalancerStatus) IsEntity()

+ func (n *LoadBalancerStatus) IsNode()

+ type LoadBalancerStatusClient struct

+ func NewLoadBalancerStatusClient(c config) *LoadBalancerStatusClient

+ func (c *LoadBalancerStatusClient) Create() *LoadBalancerStatusCreate

+ func (c *LoadBalancerStatusClient) CreateBulk(builders ...*LoadBalancerStatusCreate) *LoadBalancerStatusCreateBulk

+ func (c *LoadBalancerStatusClient) Delete() *LoadBalancerStatusDelete

+ func (c *LoadBalancerStatusClient) DeleteOne(lbs *LoadBalancerStatus) *LoadBalancerStatusDeleteOne

+ func (c *LoadBalancerStatusClient) DeleteOneID(id gidx.PrefixedID) *LoadBalancerStatusDeleteOne

+ func (c *LoadBalancerStatusClient) Get(ctx context.Context, id gidx.PrefixedID) (*LoadBalancerStatus, error)

+ func (c *LoadBalancerStatusClient) GetX(ctx context.Context, id gidx.PrefixedID) *LoadBalancerStatus

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

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

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

+ func (c *LoadBalancerStatusClient) Query() *LoadBalancerStatusQuery

+ func (c *LoadBalancerStatusClient) QueryLoadBalancer(lbs *LoadBalancerStatus) *LoadBalancerQuery

+ func (c *LoadBalancerStatusClient) Update() *LoadBalancerStatusUpdate

+ func (c *LoadBalancerStatusClient) UpdateOne(lbs *LoadBalancerStatus) *LoadBalancerStatusUpdateOne

+ func (c *LoadBalancerStatusClient) UpdateOneID(id gidx.PrefixedID) *LoadBalancerStatusUpdateOne

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

+ type LoadBalancerStatusConnection struct

+ Edges []*LoadBalancerStatusEdge

+ PageInfo PageInfo

+ TotalCount int

+ type LoadBalancerStatusCreate struct

+ func (lbsc *LoadBalancerStatusCreate) Exec(ctx context.Context) error

+ func (lbsc *LoadBalancerStatusCreate) ExecX(ctx context.Context)

+ func (lbsc *LoadBalancerStatusCreate) Mutation() *LoadBalancerStatusMutation

+ func (lbsc *LoadBalancerStatusCreate) Save(ctx context.Context) (*LoadBalancerStatus, error)

+ func (lbsc *LoadBalancerStatusCreate) SaveX(ctx context.Context) *LoadBalancerStatus

+ func (lbsc *LoadBalancerStatusCreate) SetCreatedAt(t time.Time) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetData(jm json.RawMessage) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetID(gi gidx.PrefixedID) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetLoadBalancer(l *LoadBalancer) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetLoadBalancerID(gi gidx.PrefixedID) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetNamespace(s string) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetNillableCreatedAt(t *time.Time) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetNillableID(gi *gidx.PrefixedID) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetNillableUpdatedAt(t *time.Time) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetSource(s string) *LoadBalancerStatusCreate

+ func (lbsc *LoadBalancerStatusCreate) SetUpdatedAt(t time.Time) *LoadBalancerStatusCreate

+ type LoadBalancerStatusCreateBulk struct

+ func (lbscb *LoadBalancerStatusCreateBulk) Exec(ctx context.Context) error

+ func (lbscb *LoadBalancerStatusCreateBulk) ExecX(ctx context.Context)

+ func (lbscb *LoadBalancerStatusCreateBulk) Save(ctx context.Context) ([]*LoadBalancerStatus, error)

+ func (lbscb *LoadBalancerStatusCreateBulk) SaveX(ctx context.Context) []*LoadBalancerStatus

+ type LoadBalancerStatusDelete struct

+ func (lbsd *LoadBalancerStatusDelete) Exec(ctx context.Context) (int, error)

+ func (lbsd *LoadBalancerStatusDelete) ExecX(ctx context.Context) int

+ func (lbsd *LoadBalancerStatusDelete) Where(ps ...predicate.LoadBalancerStatus) *LoadBalancerStatusDelete

+ type LoadBalancerStatusDeleteOne struct

+ func (lbsdo *LoadBalancerStatusDeleteOne) Exec(ctx context.Context) error

+ func (lbsdo *LoadBalancerStatusDeleteOne) ExecX(ctx context.Context)

+ func (lbsdo *LoadBalancerStatusDeleteOne) Where(ps ...predicate.LoadBalancerStatus) *LoadBalancerStatusDeleteOne

+ type LoadBalancerStatusEdge struct

+ Cursor Cursor

+ Node *LoadBalancerStatus

+ type LoadBalancerStatusEdges struct

+ LoadBalancer *LoadBalancer

+ func (e LoadBalancerStatusEdges) LoadBalancerOrErr() (*LoadBalancer, error)

+ type LoadBalancerStatusGroupBy struct

+ func (lbsgb *LoadBalancerStatusGroupBy) Aggregate(fns ...AggregateFunc) *LoadBalancerStatusGroupBy

+ func (lbsgb *LoadBalancerStatusGroupBy) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerStatusMutation struct

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

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

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

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

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

+ func (m *LoadBalancerStatusMutation) AppendData(jm json.RawMessage)

+ func (m *LoadBalancerStatusMutation) AppendedData() (json.RawMessage, bool)

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

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

+ func (m *LoadBalancerStatusMutation) ClearLoadBalancer()

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

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

+ func (m *LoadBalancerStatusMutation) CreatedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerStatusMutation) Data() (r json.RawMessage, exists bool)

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

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

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

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

+ func (m *LoadBalancerStatusMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerStatusMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

+ func (m *LoadBalancerStatusMutation) LoadBalancerCleared() bool

+ func (m *LoadBalancerStatusMutation) LoadBalancerID() (r gidx.PrefixedID, exists bool)

+ func (m *LoadBalancerStatusMutation) LoadBalancerIDs() (ids []gidx.PrefixedID)

+ func (m *LoadBalancerStatusMutation) Namespace() (r string, exists bool)

+ func (m *LoadBalancerStatusMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerStatusMutation) OldData(ctx context.Context) (v json.RawMessage, err error)

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

+ func (m *LoadBalancerStatusMutation) OldLoadBalancerID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *LoadBalancerStatusMutation) OldNamespace(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerStatusMutation) OldSource(ctx context.Context) (v string, err error)

+ func (m *LoadBalancerStatusMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *LoadBalancerStatusMutation) Op() Op

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

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

+ func (m *LoadBalancerStatusMutation) ResetCreatedAt()

+ func (m *LoadBalancerStatusMutation) ResetData()

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

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

+ func (m *LoadBalancerStatusMutation) ResetLoadBalancer()

+ func (m *LoadBalancerStatusMutation) ResetLoadBalancerID()

+ func (m *LoadBalancerStatusMutation) ResetNamespace()

+ func (m *LoadBalancerStatusMutation) ResetSource()

+ func (m *LoadBalancerStatusMutation) ResetUpdatedAt()

+ func (m *LoadBalancerStatusMutation) SetCreatedAt(t time.Time)

+ func (m *LoadBalancerStatusMutation) SetData(jm json.RawMessage)

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

+ func (m *LoadBalancerStatusMutation) SetID(id gidx.PrefixedID)

+ func (m *LoadBalancerStatusMutation) SetLoadBalancerID(gi gidx.PrefixedID)

+ func (m *LoadBalancerStatusMutation) SetNamespace(s string)

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

+ func (m *LoadBalancerStatusMutation) SetSource(s string)

+ func (m *LoadBalancerStatusMutation) SetUpdatedAt(t time.Time)

+ func (m *LoadBalancerStatusMutation) Source() (r string, exists bool)

+ func (m *LoadBalancerStatusMutation) Type() string

+ func (m *LoadBalancerStatusMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *LoadBalancerStatusMutation) Where(ps ...predicate.LoadBalancerStatus)

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

+ func (m LoadBalancerStatusMutation) Client() *Client

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

+ type LoadBalancerStatusOrder struct

+ Direction OrderDirection

+ Field *LoadBalancerStatusOrderField

+ type LoadBalancerStatusOrderField struct

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

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

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

+ func (f LoadBalancerStatusOrderField) String() string

+ type LoadBalancerStatusPaginateOption func(*loadbalancerstatusPager) error

+ func WithLoadBalancerStatusFilter(filter func(*LoadBalancerStatusQuery) (*LoadBalancerStatusQuery, error)) LoadBalancerStatusPaginateOption

+ func WithLoadBalancerStatusOrder(order *LoadBalancerStatusOrder) LoadBalancerStatusPaginateOption

+ type LoadBalancerStatusQuery struct

+ func (lbs *LoadBalancerStatusQuery) CollectFields(ctx context.Context, satisfies ...string) (*LoadBalancerStatusQuery, error)

+ func (lbs *LoadBalancerStatusQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerStatusConnection, error)

+ func (lbsq *LoadBalancerStatusQuery) Aggregate(fns ...AggregateFunc) *LoadBalancerStatusSelect

+ func (lbsq *LoadBalancerStatusQuery) All(ctx context.Context) ([]*LoadBalancerStatus, error)

+ func (lbsq *LoadBalancerStatusQuery) AllX(ctx context.Context) []*LoadBalancerStatus

+ func (lbsq *LoadBalancerStatusQuery) Clone() *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) Count(ctx context.Context) (int, error)

+ func (lbsq *LoadBalancerStatusQuery) CountX(ctx context.Context) int

+ func (lbsq *LoadBalancerStatusQuery) Exist(ctx context.Context) (bool, error)

+ func (lbsq *LoadBalancerStatusQuery) ExistX(ctx context.Context) bool

+ func (lbsq *LoadBalancerStatusQuery) First(ctx context.Context) (*LoadBalancerStatus, error)

+ func (lbsq *LoadBalancerStatusQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbsq *LoadBalancerStatusQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (lbsq *LoadBalancerStatusQuery) FirstX(ctx context.Context) *LoadBalancerStatus

+ func (lbsq *LoadBalancerStatusQuery) GroupBy(field string, fields ...string) *LoadBalancerStatusGroupBy

+ func (lbsq *LoadBalancerStatusQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (lbsq *LoadBalancerStatusQuery) IDsX(ctx context.Context) []gidx.PrefixedID

+ func (lbsq *LoadBalancerStatusQuery) Limit(limit int) *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) Offset(offset int) *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) Only(ctx context.Context) (*LoadBalancerStatus, error)

+ func (lbsq *LoadBalancerStatusQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (lbsq *LoadBalancerStatusQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (lbsq *LoadBalancerStatusQuery) OnlyX(ctx context.Context) *LoadBalancerStatus

+ func (lbsq *LoadBalancerStatusQuery) Order(o ...loadbalancerstatus.OrderOption) *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) QueryLoadBalancer() *LoadBalancerQuery

+ func (lbsq *LoadBalancerStatusQuery) Select(fields ...string) *LoadBalancerStatusSelect

+ func (lbsq *LoadBalancerStatusQuery) Unique(unique bool) *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) Where(ps ...predicate.LoadBalancerStatus) *LoadBalancerStatusQuery

+ func (lbsq *LoadBalancerStatusQuery) WithLoadBalancer(opts ...func(*LoadBalancerQuery)) *LoadBalancerStatusQuery

+ type LoadBalancerStatusSelect struct

+ func (lbss *LoadBalancerStatusSelect) Aggregate(fns ...AggregateFunc) *LoadBalancerStatusSelect

+ func (lbss *LoadBalancerStatusSelect) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type LoadBalancerStatusSlice []*LoadBalancerStatus

+ type LoadBalancerStatusUpdate struct

+ func (lbsu *LoadBalancerStatusUpdate) AppendData(jm json.RawMessage) *LoadBalancerStatusUpdate

+ func (lbsu *LoadBalancerStatusUpdate) Exec(ctx context.Context) error

+ func (lbsu *LoadBalancerStatusUpdate) ExecX(ctx context.Context)

+ func (lbsu *LoadBalancerStatusUpdate) Mutation() *LoadBalancerStatusMutation

+ func (lbsu *LoadBalancerStatusUpdate) Save(ctx context.Context) (int, error)

+ func (lbsu *LoadBalancerStatusUpdate) SaveX(ctx context.Context) int

+ func (lbsu *LoadBalancerStatusUpdate) SetData(jm json.RawMessage) *LoadBalancerStatusUpdate

+ func (lbsu *LoadBalancerStatusUpdate) SetNamespace(s string) *LoadBalancerStatusUpdate

+ func (lbsu *LoadBalancerStatusUpdate) Where(ps ...predicate.LoadBalancerStatus) *LoadBalancerStatusUpdate

+ type LoadBalancerStatusUpdateOne struct

+ func (lbsuo *LoadBalancerStatusUpdateOne) AppendData(jm json.RawMessage) *LoadBalancerStatusUpdateOne

+ func (lbsuo *LoadBalancerStatusUpdateOne) Exec(ctx context.Context) error

+ func (lbsuo *LoadBalancerStatusUpdateOne) ExecX(ctx context.Context)

+ func (lbsuo *LoadBalancerStatusUpdateOne) Mutation() *LoadBalancerStatusMutation

+ func (lbsuo *LoadBalancerStatusUpdateOne) Save(ctx context.Context) (*LoadBalancerStatus, error)

+ func (lbsuo *LoadBalancerStatusUpdateOne) SaveX(ctx context.Context) *LoadBalancerStatus

+ func (lbsuo *LoadBalancerStatusUpdateOne) Select(field string, fields ...string) *LoadBalancerStatusUpdateOne

+ func (lbsuo *LoadBalancerStatusUpdateOne) SetData(jm json.RawMessage) *LoadBalancerStatusUpdateOne

+ func (lbsuo *LoadBalancerStatusUpdateOne) SetNamespace(s string) *LoadBalancerStatusUpdateOne

+ func (lbsuo *LoadBalancerStatusUpdateOne) Where(ps ...predicate.LoadBalancerStatus) *LoadBalancerStatusUpdateOne

+ type LoadBalancerStatusWhereInput struct

+ And []*LoadBalancerStatusWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasLoadBalancer *bool

+ HasLoadBalancerWith []*LoadBalancerWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ Namespace *string

+ NamespaceContains *string

+ NamespaceContainsFold *string

+ NamespaceEqualFold *string

+ NamespaceGT *string

+ NamespaceGTE *string

+ NamespaceHasPrefix *string

+ NamespaceHasSuffix *string

+ NamespaceIn []string

+ NamespaceLT *string

+ NamespaceLTE *string

+ NamespaceNEQ *string

+ NamespaceNotIn []string

+ Not *LoadBalancerStatusWhereInput

+ Or []*LoadBalancerStatusWhereInput

+ Predicates []predicate.LoadBalancerStatus

+ Source *string

+ SourceContains *string

+ SourceContainsFold *string

+ SourceEqualFold *string

+ SourceGT *string

+ SourceGTE *string

+ SourceHasPrefix *string

+ SourceHasSuffix *string

+ SourceIn []string

+ SourceLT *string

+ SourceLTE *string

+ SourceNEQ *string

+ SourceNotIn []string

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerStatusWhereInput) AddPredicates(predicates ...predicate.LoadBalancerStatus)

+ func (i *LoadBalancerStatusWhereInput) Filter(q *LoadBalancerStatusQuery) (*LoadBalancerStatusQuery, error)

+ func (i *LoadBalancerStatusWhereInput) P() (predicate.LoadBalancerStatus, error)

+ type LoadBalancerUpdate struct

+ func (c *LoadBalancerUpdate) SetInput(i UpdateLoadBalancerInput) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddAnnotationIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddAnnotations(l ...*LoadBalancerAnnotation) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddPortIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddPorts(p ...*Port) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddStatusIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) AddStatuses(l ...*LoadBalancerStatus) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearAnnotations() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearPorts() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) ClearStatuses() *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) Exec(ctx context.Context) error

+ func (lbu *LoadBalancerUpdate) ExecX(ctx context.Context)

+ func (lbu *LoadBalancerUpdate) Mutation() *LoadBalancerMutation

+ func (lbu *LoadBalancerUpdate) RemoveAnnotationIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) RemoveAnnotations(l ...*LoadBalancerAnnotation) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) RemovePortIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) RemovePorts(p ...*Port) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) RemoveStatusIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) RemoveStatuses(l ...*LoadBalancerStatus) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) Save(ctx context.Context) (int, error)

+ func (lbu *LoadBalancerUpdate) SaveX(ctx context.Context) int

+ func (lbu *LoadBalancerUpdate) SetName(s string) *LoadBalancerUpdate

+ func (lbu *LoadBalancerUpdate) Where(ps ...predicate.LoadBalancer) *LoadBalancerUpdate

+ type LoadBalancerUpdateOne struct

+ func (c *LoadBalancerUpdateOne) SetInput(i UpdateLoadBalancerInput) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddAnnotationIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddAnnotations(l ...*LoadBalancerAnnotation) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddPortIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddPorts(p ...*Port) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddStatusIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) AddStatuses(l ...*LoadBalancerStatus) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearAnnotations() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearPorts() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) ClearStatuses() *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) Exec(ctx context.Context) error

+ func (lbuo *LoadBalancerUpdateOne) ExecX(ctx context.Context)

+ func (lbuo *LoadBalancerUpdateOne) Mutation() *LoadBalancerMutation

+ func (lbuo *LoadBalancerUpdateOne) RemoveAnnotationIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) RemoveAnnotations(l ...*LoadBalancerAnnotation) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) RemovePortIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) RemovePorts(p ...*Port) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) RemoveStatusIDs(ids ...gidx.PrefixedID) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) RemoveStatuses(l ...*LoadBalancerStatus) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) Save(ctx context.Context) (*LoadBalancer, error)

+ func (lbuo *LoadBalancerUpdateOne) SaveX(ctx context.Context) *LoadBalancer

+ func (lbuo *LoadBalancerUpdateOne) Select(field string, fields ...string) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) SetName(s string) *LoadBalancerUpdateOne

+ func (lbuo *LoadBalancerUpdateOne) Where(ps ...predicate.LoadBalancer) *LoadBalancerUpdateOne

+ type LoadBalancerWhereInput struct

+ And []*LoadBalancerWhereInput

+ CreatedAt *time.Time

+ CreatedAtGT *time.Time

+ CreatedAtGTE *time.Time

+ CreatedAtIn []time.Time

+ CreatedAtLT *time.Time

+ CreatedAtLTE *time.Time

+ CreatedAtNEQ *time.Time

+ CreatedAtNotIn []time.Time

+ HasAnnotations *bool

+ HasAnnotationsWith []*LoadBalancerAnnotationWhereInput

+ HasPorts *bool

+ HasPortsWith []*LoadBalancerPortWhereInput

+ HasProvider *bool

+ HasProviderWith []*LoadBalancerProviderWhereInput

+ HasStatuses *bool

+ HasStatusesWith []*LoadBalancerStatusWhereInput

+ ID *gidx.PrefixedID

+ IDGT *gidx.PrefixedID

+ IDGTE *gidx.PrefixedID

+ IDIn []gidx.PrefixedID

+ IDLT *gidx.PrefixedID

+ IDLTE *gidx.PrefixedID

+ IDNEQ *gidx.PrefixedID

+ IDNotIn []gidx.PrefixedID

+ 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 *LoadBalancerWhereInput

+ Or []*LoadBalancerWhereInput

+ Predicates []predicate.LoadBalancer

+ UpdatedAt *time.Time

+ UpdatedAtGT *time.Time

+ UpdatedAtGTE *time.Time

+ UpdatedAtIn []time.Time

+ UpdatedAtLT *time.Time

+ UpdatedAtLTE *time.Time

+ UpdatedAtNEQ *time.Time

+ UpdatedAtNotIn []time.Time

+ func (i *LoadBalancerWhereInput) AddPredicates(predicates ...predicate.LoadBalancer)

+ func (i *LoadBalancerWhereInput) Filter(q *LoadBalancerQuery) (*LoadBalancerQuery, error)

+ func (i *LoadBalancerWhereInput) P() (predicate.LoadBalancer, error)

+ type LoadBalancers []*LoadBalancer

+ type MutateFunc = ent.MutateFunc

+ type Mutation = ent.Mutation

+ type Mutator = ent.Mutator

+ type NodeOption func(*nodeOptions)

+ func WithFixedNodeType(t string) NodeOption

+ func WithNodeType(f func(context.Context, gidx.PrefixedID) (string, error)) NodeOption

+ type Noder interface

+ IsNode func()

+ 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(...any)) Option

+ func PubsubClient(v *pubsub.Client) Option

+ type OrderDirection = entgql.OrderDirection

+ type OrderFunc func(*sql.Selector)

+ type Origin struct

+ Active bool

+ CreatedAt time.Time

+ Edges OriginEdges

+ ID gidx.PrefixedID

+ Name string

+ PoolID gidx.PrefixedID

+ PortNumber int

+ Target string

+ UpdatedAt time.Time

+ func (n *Origin) IsNode()

+ func (o *Origin) Pool(ctx context.Context) (*Pool, error)

+ func (o *Origin) QueryPool() *PoolQuery

+ func (o *Origin) String() string

+ func (o *Origin) Unwrap() *Origin

+ func (o *Origin) Update() *OriginUpdateOne

+ func (o *Origin) Value(name string) (ent.Value, error)

+ func (o Origin) IsEntity()

+ type OriginClient struct

+ func NewOriginClient(c config) *OriginClient

+ func (c *OriginClient) Create() *OriginCreate

+ func (c *OriginClient) CreateBulk(builders ...*OriginCreate) *OriginCreateBulk

+ func (c *OriginClient) Delete() *OriginDelete

+ func (c *OriginClient) DeleteOne(o *Origin) *OriginDeleteOne

+ func (c *OriginClient) DeleteOneID(id gidx.PrefixedID) *OriginDeleteOne

+ func (c *OriginClient) Get(ctx context.Context, id gidx.PrefixedID) (*Origin, error)

+ func (c *OriginClient) GetX(ctx context.Context, id gidx.PrefixedID) *Origin

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

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

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

+ func (c *OriginClient) Query() *OriginQuery

+ func (c *OriginClient) QueryPool(o *Origin) *PoolQuery

+ func (c *OriginClient) Update() *OriginUpdate

+ func (c *OriginClient) UpdateOne(o *Origin) *OriginUpdateOne

+ func (c *OriginClient) UpdateOneID(id gidx.PrefixedID) *OriginUpdateOne

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

+ type OriginCreate struct

+ func (c *OriginCreate) SetInput(i CreateLoadBalancerOriginInput) *OriginCreate

+ func (oc *OriginCreate) Exec(ctx context.Context) error

+ func (oc *OriginCreate) ExecX(ctx context.Context)

+ func (oc *OriginCreate) Mutation() *OriginMutation

+ func (oc *OriginCreate) Save(ctx context.Context) (*Origin, error)

+ func (oc *OriginCreate) SaveX(ctx context.Context) *Origin

+ func (oc *OriginCreate) SetActive(b bool) *OriginCreate

+ func (oc *OriginCreate) SetCreatedAt(t time.Time) *OriginCreate

+ func (oc *OriginCreate) SetID(gi gidx.PrefixedID) *OriginCreate

+ func (oc *OriginCreate) SetName(s string) *OriginCreate

+ func (oc *OriginCreate) SetNillableActive(b *bool) *OriginCreate

+ func (oc *OriginCreate) SetNillableCreatedAt(t *time.Time) *OriginCreate

+ func (oc *OriginCreate) SetNillableID(gi *gidx.PrefixedID) *OriginCreate

+ func (oc *OriginCreate) SetNillableUpdatedAt(t *time.Time) *OriginCreate

+ func (oc *OriginCreate) SetPool(p *Pool) *OriginCreate

+ func (oc *OriginCreate) SetPoolID(gi gidx.PrefixedID) *OriginCreate

+ func (oc *OriginCreate) SetPortNumber(i int) *OriginCreate

+ func (oc *OriginCreate) SetTarget(s string) *OriginCreate

+ func (oc *OriginCreate) SetUpdatedAt(t time.Time) *OriginCreate

+ type OriginCreateBulk struct

+ func (ocb *OriginCreateBulk) Exec(ctx context.Context) error

+ func (ocb *OriginCreateBulk) ExecX(ctx context.Context)

+ func (ocb *OriginCreateBulk) Save(ctx context.Context) ([]*Origin, error)

+ func (ocb *OriginCreateBulk) SaveX(ctx context.Context) []*Origin

+ type OriginDelete struct

+ func (od *OriginDelete) Exec(ctx context.Context) (int, error)

+ func (od *OriginDelete) ExecX(ctx context.Context) int

+ func (od *OriginDelete) Where(ps ...predicate.Origin) *OriginDelete

+ type OriginDeleteOne struct

+ func (odo *OriginDeleteOne) Exec(ctx context.Context) error

+ func (odo *OriginDeleteOne) ExecX(ctx context.Context)

+ func (odo *OriginDeleteOne) Where(ps ...predicate.Origin) *OriginDeleteOne

+ type OriginEdges struct

+ Pool *Pool

+ func (e OriginEdges) PoolOrErr() (*Pool, error)

+ type OriginGroupBy struct

+ func (ogb *OriginGroupBy) Aggregate(fns ...AggregateFunc) *OriginGroupBy

+ func (ogb *OriginGroupBy) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type OriginMutation struct

+ func (m *OriginMutation) Active() (r bool, exists bool)

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

+ func (m *OriginMutation) AddPortNumber(i int)

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

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

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

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

+ func (m *OriginMutation) AddedPortNumber() (r int, exists bool)

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

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

+ func (m *OriginMutation) ClearPool()

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

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

+ func (m *OriginMutation) CreatedAt() (r time.Time, exists bool)

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

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

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

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

+ func (m *OriginMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *OriginMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

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

+ func (m *OriginMutation) OldActive(ctx context.Context) (v bool, err error)

+ func (m *OriginMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

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

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

+ func (m *OriginMutation) OldPoolID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *OriginMutation) OldPortNumber(ctx context.Context) (v int, err error)

+ func (m *OriginMutation) OldTarget(ctx context.Context) (v string, err error)

+ func (m *OriginMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *OriginMutation) Op() Op

+ func (m *OriginMutation) PoolCleared() bool

+ func (m *OriginMutation) PoolID() (r gidx.PrefixedID, exists bool)

+ func (m *OriginMutation) PoolIDs() (ids []gidx.PrefixedID)

+ func (m *OriginMutation) PortNumber() (r int, exists bool)

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

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

+ func (m *OriginMutation) ResetActive()

+ func (m *OriginMutation) ResetCreatedAt()

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

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

+ func (m *OriginMutation) ResetName()

+ func (m *OriginMutation) ResetPool()

+ func (m *OriginMutation) ResetPoolID()

+ func (m *OriginMutation) ResetPortNumber()

+ func (m *OriginMutation) ResetTarget()

+ func (m *OriginMutation) ResetUpdatedAt()

+ func (m *OriginMutation) SetActive(b bool)

+ func (m *OriginMutation) SetCreatedAt(t time.Time)

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

+ func (m *OriginMutation) SetID(id gidx.PrefixedID)

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

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

+ func (m *OriginMutation) SetPoolID(gi gidx.PrefixedID)

+ func (m *OriginMutation) SetPortNumber(i int)

+ func (m *OriginMutation) SetTarget(s string)

+ func (m *OriginMutation) SetUpdatedAt(t time.Time)

+ func (m *OriginMutation) Target() (r string, exists bool)

+ func (m *OriginMutation) Type() string

+ func (m *OriginMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *OriginMutation) Where(ps ...predicate.Origin)

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

+ func (m OriginMutation) Client() *Client

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

+ type OriginQuery struct

+ func (o *OriginQuery) CollectFields(ctx context.Context, satisfies ...string) (*OriginQuery, error)

+ func (o *OriginQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerOriginConnection, error)

+ func (oq *OriginQuery) Aggregate(fns ...AggregateFunc) *OriginSelect

+ func (oq *OriginQuery) All(ctx context.Context) ([]*Origin, error)

+ func (oq *OriginQuery) AllX(ctx context.Context) []*Origin

+ func (oq *OriginQuery) Clone() *OriginQuery

+ func (oq *OriginQuery) Count(ctx context.Context) (int, error)

+ func (oq *OriginQuery) CountX(ctx context.Context) int

+ func (oq *OriginQuery) Exist(ctx context.Context) (bool, error)

+ func (oq *OriginQuery) ExistX(ctx context.Context) bool

+ func (oq *OriginQuery) First(ctx context.Context) (*Origin, error)

+ func (oq *OriginQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (oq *OriginQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (oq *OriginQuery) FirstX(ctx context.Context) *Origin

+ func (oq *OriginQuery) GroupBy(field string, fields ...string) *OriginGroupBy

+ func (oq *OriginQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (oq *OriginQuery) IDsX(ctx context.Context) []gidx.PrefixedID

+ func (oq *OriginQuery) Limit(limit int) *OriginQuery

+ func (oq *OriginQuery) Offset(offset int) *OriginQuery

+ func (oq *OriginQuery) Only(ctx context.Context) (*Origin, error)

+ func (oq *OriginQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (oq *OriginQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (oq *OriginQuery) OnlyX(ctx context.Context) *Origin

+ func (oq *OriginQuery) Order(o ...origin.OrderOption) *OriginQuery

+ func (oq *OriginQuery) QueryPool() *PoolQuery

+ func (oq *OriginQuery) Select(fields ...string) *OriginSelect

+ func (oq *OriginQuery) Unique(unique bool) *OriginQuery

+ func (oq *OriginQuery) Where(ps ...predicate.Origin) *OriginQuery

+ func (oq *OriginQuery) WithPool(opts ...func(*PoolQuery)) *OriginQuery

+ type OriginSelect struct

+ func (os *OriginSelect) Aggregate(fns ...AggregateFunc) *OriginSelect

+ func (os *OriginSelect) Scan(ctx context.Context, v any) error

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type OriginUpdate struct

+ func (c *OriginUpdate) SetInput(i UpdateLoadBalancerOriginInput) *OriginUpdate

+ func (ou *OriginUpdate) AddPortNumber(i int) *OriginUpdate

+ func (ou *OriginUpdate) Exec(ctx context.Context) error

+ func (ou *OriginUpdate) ExecX(ctx context.Context)

+ func (ou *OriginUpdate) Mutation() *OriginMutation

+ func (ou *OriginUpdate) Save(ctx context.Context) (int, error)

+ func (ou *OriginUpdate) SaveX(ctx context.Context) int

+ func (ou *OriginUpdate) SetActive(b bool) *OriginUpdate

+ func (ou *OriginUpdate) SetName(s string) *OriginUpdate

+ func (ou *OriginUpdate) SetNillableActive(b *bool) *OriginUpdate

+ func (ou *OriginUpdate) SetPortNumber(i int) *OriginUpdate

+ func (ou *OriginUpdate) SetTarget(s string) *OriginUpdate

+ func (ou *OriginUpdate) Where(ps ...predicate.Origin) *OriginUpdate

+ type OriginUpdateOne struct

+ func (c *OriginUpdateOne) SetInput(i UpdateLoadBalancerOriginInput) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) AddPortNumber(i int) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) Exec(ctx context.Context) error

+ func (ouo *OriginUpdateOne) ExecX(ctx context.Context)

+ func (ouo *OriginUpdateOne) Mutation() *OriginMutation

+ func (ouo *OriginUpdateOne) Save(ctx context.Context) (*Origin, error)

+ func (ouo *OriginUpdateOne) SaveX(ctx context.Context) *Origin

+ func (ouo *OriginUpdateOne) Select(field string, fields ...string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetActive(b bool) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetName(s string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetNillableActive(b *bool) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetPortNumber(i int) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) SetTarget(s string) *OriginUpdateOne

+ func (ouo *OriginUpdateOne) Where(ps ...predicate.Origin) *OriginUpdateOne

+ type Origins []*Origin

+ type PageInfo = entgql.PageInfo[gidx.PrefixedID]

+ type Policy = ent.Policy

+ type Pool struct

+ CreatedAt time.Time

+ Edges PoolEdges

+ ID gidx.PrefixedID

+ Name string

+ Protocol pool.Protocol

+ TenantID gidx.PrefixedID

+ UpdatedAt time.Time

+ func (n *Pool) IsNode()

+ func (po *Pool) NamedOrigins(name string) ([]*Origin, error)

+ func (po *Pool) NamedPorts(name string) ([]*Port, error)

+ func (po *Pool) Origins(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerOriginConnection, error)

+ func (po *Pool) Ports(ctx context.Context) (result []*Port, err error)

+ func (po *Pool) QueryOrigins() *OriginQuery

+ func (po *Pool) QueryPorts() *PortQuery

+ func (po *Pool) String() string

+ func (po *Pool) Unwrap() *Pool

+ func (po *Pool) Update() *PoolUpdateOne

+ func (po *Pool) Value(name string) (ent.Value, error)

+ func (po Pool) IsEntity()

+ type PoolClient struct

+ func NewPoolClient(c config) *PoolClient

+ func (c *PoolClient) Create() *PoolCreate

+ func (c *PoolClient) CreateBulk(builders ...*PoolCreate) *PoolCreateBulk

+ func (c *PoolClient) Delete() *PoolDelete

+ func (c *PoolClient) DeleteOne(po *Pool) *PoolDeleteOne

+ func (c *PoolClient) DeleteOneID(id gidx.PrefixedID) *PoolDeleteOne

+ func (c *PoolClient) Get(ctx context.Context, id gidx.PrefixedID) (*Pool, error)

+ func (c *PoolClient) GetX(ctx context.Context, id gidx.PrefixedID) *Pool

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

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

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

+ func (c *PoolClient) Query() *PoolQuery

+ func (c *PoolClient) QueryOrigins(po *Pool) *OriginQuery

+ func (c *PoolClient) QueryPorts(po *Pool) *PortQuery

+ func (c *PoolClient) Update() *PoolUpdate

+ func (c *PoolClient) UpdateOne(po *Pool) *PoolUpdateOne

+ func (c *PoolClient) UpdateOneID(id gidx.PrefixedID) *PoolUpdateOne

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

+ type PoolCreate struct

+ func (c *PoolCreate) SetInput(i CreateLoadBalancerPoolInput) *PoolCreate

+ func (pc *PoolCreate) AddOriginIDs(ids ...gidx.PrefixedID) *PoolCreate

+ func (pc *PoolCreate) AddOrigins(o ...*Origin) *PoolCreate

+ func (pc *PoolCreate) AddPortIDs(ids ...gidx.PrefixedID) *PoolCreate

+ func (pc *PoolCreate) AddPorts(p ...*Port) *PoolCreate

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

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

+ func (pc *PoolCreate) Mutation() *PoolMutation

+ func (pc *PoolCreate) Save(ctx context.Context) (*Pool, error)

+ func (pc *PoolCreate) SaveX(ctx context.Context) *Pool

+ func (pc *PoolCreate) SetCreatedAt(t time.Time) *PoolCreate

+ func (pc *PoolCreate) SetID(gi gidx.PrefixedID) *PoolCreate

+ func (pc *PoolCreate) SetName(s string) *PoolCreate

+ func (pc *PoolCreate) SetNillableCreatedAt(t *time.Time) *PoolCreate

+ func (pc *PoolCreate) SetNillableID(gi *gidx.PrefixedID) *PoolCreate

+ func (pc *PoolCreate) SetNillableUpdatedAt(t *time.Time) *PoolCreate

+ func (pc *PoolCreate) SetProtocol(po pool.Protocol) *PoolCreate

+ func (pc *PoolCreate) SetTenantID(gi gidx.PrefixedID) *PoolCreate

+ func (pc *PoolCreate) SetUpdatedAt(t time.Time) *PoolCreate

+ type PoolCreateBulk struct

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

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

+ func (pcb *PoolCreateBulk) Save(ctx context.Context) ([]*Pool, error)

+ func (pcb *PoolCreateBulk) SaveX(ctx context.Context) []*Pool

+ type PoolDelete struct

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

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

+ func (pd *PoolDelete) Where(ps ...predicate.Pool) *PoolDelete

+ type PoolDeleteOne struct

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

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

+ func (pdo *PoolDeleteOne) Where(ps ...predicate.Pool) *PoolDeleteOne

+ type PoolEdges struct

+ Origins []*Origin

+ Ports []*Port

+ func (e PoolEdges) OriginsOrErr() ([]*Origin, error)

+ func (e PoolEdges) PortsOrErr() ([]*Port, error)

+ type PoolGroupBy struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type PoolMutation struct

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

+ func (m *PoolMutation) AddOriginIDs(ids ...gidx.PrefixedID)

+ func (m *PoolMutation) AddPortIDs(ids ...gidx.PrefixedID)

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

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

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

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

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

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

+ func (m *PoolMutation) ClearOrigins()

+ func (m *PoolMutation) ClearPorts()

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

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

+ func (m *PoolMutation) CreatedAt() (r time.Time, exists bool)

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

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

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

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

+ func (m *PoolMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *PoolMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

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

+ func (m *PoolMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

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

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

+ func (m *PoolMutation) OldProtocol(ctx context.Context) (v pool.Protocol, err error)

+ func (m *PoolMutation) OldTenantID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *PoolMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PoolMutation) Op() Op

+ func (m *PoolMutation) OriginsCleared() bool

+ func (m *PoolMutation) OriginsIDs() (ids []gidx.PrefixedID)

+ func (m *PoolMutation) PortsCleared() bool

+ func (m *PoolMutation) PortsIDs() (ids []gidx.PrefixedID)

+ func (m *PoolMutation) Protocol() (r pool.Protocol, exists bool)

+ func (m *PoolMutation) RemoveOriginIDs(ids ...gidx.PrefixedID)

+ func (m *PoolMutation) RemovePortIDs(ids ...gidx.PrefixedID)

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

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

+ func (m *PoolMutation) RemovedOriginsIDs() (ids []gidx.PrefixedID)

+ func (m *PoolMutation) RemovedPortsIDs() (ids []gidx.PrefixedID)

+ func (m *PoolMutation) ResetCreatedAt()

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

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

+ func (m *PoolMutation) ResetName()

+ func (m *PoolMutation) ResetOrigins()

+ func (m *PoolMutation) ResetPorts()

+ func (m *PoolMutation) ResetProtocol()

+ func (m *PoolMutation) ResetTenantID()

+ func (m *PoolMutation) ResetUpdatedAt()

+ func (m *PoolMutation) SetCreatedAt(t time.Time)

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

+ func (m *PoolMutation) SetID(id gidx.PrefixedID)

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

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

+ func (m *PoolMutation) SetProtocol(po pool.Protocol)

+ func (m *PoolMutation) SetTenantID(gi gidx.PrefixedID)

+ func (m *PoolMutation) SetUpdatedAt(t time.Time)

+ func (m *PoolMutation) TenantID() (r gidx.PrefixedID, exists bool)

+ func (m *PoolMutation) Type() string

+ func (m *PoolMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *PoolMutation) Where(ps ...predicate.Pool)

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

+ func (m PoolMutation) Client() *Client

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

+ type PoolQuery struct

+ func (po *PoolQuery) CollectFields(ctx context.Context, satisfies ...string) (*PoolQuery, error)

+ func (po *PoolQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerPoolConnection, error)

+ func (pq *PoolQuery) Aggregate(fns ...AggregateFunc) *PoolSelect

+ func (pq *PoolQuery) All(ctx context.Context) ([]*Pool, error)

+ func (pq *PoolQuery) AllX(ctx context.Context) []*Pool

+ func (pq *PoolQuery) Clone() *PoolQuery

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

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

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

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

+ func (pq *PoolQuery) First(ctx context.Context) (*Pool, error)

+ func (pq *PoolQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *PoolQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *PoolQuery) FirstX(ctx context.Context) *Pool

+ func (pq *PoolQuery) GroupBy(field string, fields ...string) *PoolGroupBy

+ func (pq *PoolQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (pq *PoolQuery) IDsX(ctx context.Context) []gidx.PrefixedID

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

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

+ func (pq *PoolQuery) Only(ctx context.Context) (*Pool, error)

+ func (pq *PoolQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *PoolQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *PoolQuery) OnlyX(ctx context.Context) *Pool

+ func (pq *PoolQuery) Order(o ...pool.OrderOption) *PoolQuery

+ func (pq *PoolQuery) QueryOrigins() *OriginQuery

+ func (pq *PoolQuery) QueryPorts() *PortQuery

+ func (pq *PoolQuery) Select(fields ...string) *PoolSelect

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

+ func (pq *PoolQuery) Where(ps ...predicate.Pool) *PoolQuery

+ func (pq *PoolQuery) WithNamedOrigins(name string, opts ...func(*OriginQuery)) *PoolQuery

+ func (pq *PoolQuery) WithNamedPorts(name string, opts ...func(*PortQuery)) *PoolQuery

+ func (pq *PoolQuery) WithOrigins(opts ...func(*OriginQuery)) *PoolQuery

+ func (pq *PoolQuery) WithPorts(opts ...func(*PortQuery)) *PoolQuery

+ type PoolSelect struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type PoolUpdate struct

+ func (c *PoolUpdate) SetInput(i UpdateLoadBalancerPoolInput) *PoolUpdate

+ func (pu *PoolUpdate) AddOriginIDs(ids ...gidx.PrefixedID) *PoolUpdate

+ func (pu *PoolUpdate) AddOrigins(o ...*Origin) *PoolUpdate

+ func (pu *PoolUpdate) AddPortIDs(ids ...gidx.PrefixedID) *PoolUpdate

+ func (pu *PoolUpdate) AddPorts(p ...*Port) *PoolUpdate

+ func (pu *PoolUpdate) ClearOrigins() *PoolUpdate

+ func (pu *PoolUpdate) ClearPorts() *PoolUpdate

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

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

+ func (pu *PoolUpdate) Mutation() *PoolMutation

+ func (pu *PoolUpdate) RemoveOriginIDs(ids ...gidx.PrefixedID) *PoolUpdate

+ func (pu *PoolUpdate) RemoveOrigins(o ...*Origin) *PoolUpdate

+ func (pu *PoolUpdate) RemovePortIDs(ids ...gidx.PrefixedID) *PoolUpdate

+ func (pu *PoolUpdate) RemovePorts(p ...*Port) *PoolUpdate

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

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

+ func (pu *PoolUpdate) SetName(s string) *PoolUpdate

+ func (pu *PoolUpdate) SetProtocol(po pool.Protocol) *PoolUpdate

+ func (pu *PoolUpdate) Where(ps ...predicate.Pool) *PoolUpdate

+ type PoolUpdateOne struct

+ func (c *PoolUpdateOne) SetInput(i UpdateLoadBalancerPoolInput) *PoolUpdateOne

+ func (puo *PoolUpdateOne) AddOriginIDs(ids ...gidx.PrefixedID) *PoolUpdateOne

+ func (puo *PoolUpdateOne) AddOrigins(o ...*Origin) *PoolUpdateOne

+ func (puo *PoolUpdateOne) AddPortIDs(ids ...gidx.PrefixedID) *PoolUpdateOne

+ func (puo *PoolUpdateOne) AddPorts(p ...*Port) *PoolUpdateOne

+ func (puo *PoolUpdateOne) ClearOrigins() *PoolUpdateOne

+ func (puo *PoolUpdateOne) ClearPorts() *PoolUpdateOne

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

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

+ func (puo *PoolUpdateOne) Mutation() *PoolMutation

+ func (puo *PoolUpdateOne) RemoveOriginIDs(ids ...gidx.PrefixedID) *PoolUpdateOne

+ func (puo *PoolUpdateOne) RemoveOrigins(o ...*Origin) *PoolUpdateOne

+ func (puo *PoolUpdateOne) RemovePortIDs(ids ...gidx.PrefixedID) *PoolUpdateOne

+ func (puo *PoolUpdateOne) RemovePorts(p ...*Port) *PoolUpdateOne

+ func (puo *PoolUpdateOne) Save(ctx context.Context) (*Pool, error)

+ func (puo *PoolUpdateOne) SaveX(ctx context.Context) *Pool

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

+ func (puo *PoolUpdateOne) SetName(s string) *PoolUpdateOne

+ func (puo *PoolUpdateOne) SetProtocol(po pool.Protocol) *PoolUpdateOne

+ func (puo *PoolUpdateOne) Where(ps ...predicate.Pool) *PoolUpdateOne

+ type Pools []*Pool

+ type Port struct

+ CreatedAt time.Time

+ Edges PortEdges

+ ID gidx.PrefixedID

+ LoadBalancerID gidx.PrefixedID

+ Name string

+ Number int

+ UpdatedAt time.Time

+ func (n *Port) IsNode()

+ func (po *Port) LoadBalancer(ctx context.Context) (*LoadBalancer, error)

+ func (po *Port) NamedPools(name string) ([]*Pool, error)

+ func (po *Port) Pools(ctx context.Context) (result []*Pool, err error)

+ func (po *Port) QueryLoadBalancer() *LoadBalancerQuery

+ func (po *Port) QueryPools() *PoolQuery

+ func (po *Port) String() string

+ func (po *Port) Unwrap() *Port

+ func (po *Port) Update() *PortUpdateOne

+ func (po *Port) Value(name string) (ent.Value, error)

+ func (po Port) IsEntity()

+ type PortClient struct

+ func NewPortClient(c config) *PortClient

+ func (c *PortClient) Create() *PortCreate

+ func (c *PortClient) CreateBulk(builders ...*PortCreate) *PortCreateBulk

+ func (c *PortClient) Delete() *PortDelete

+ func (c *PortClient) DeleteOne(po *Port) *PortDeleteOne

+ func (c *PortClient) DeleteOneID(id gidx.PrefixedID) *PortDeleteOne

+ func (c *PortClient) Get(ctx context.Context, id gidx.PrefixedID) (*Port, error)

+ func (c *PortClient) GetX(ctx context.Context, id gidx.PrefixedID) *Port

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

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

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

+ func (c *PortClient) Query() *PortQuery

+ func (c *PortClient) QueryLoadBalancer(po *Port) *LoadBalancerQuery

+ func (c *PortClient) QueryPools(po *Port) *PoolQuery

+ func (c *PortClient) Update() *PortUpdate

+ func (c *PortClient) UpdateOne(po *Port) *PortUpdateOne

+ func (c *PortClient) UpdateOneID(id gidx.PrefixedID) *PortUpdateOne

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

+ type PortCreate struct

+ func (c *PortCreate) SetInput(i CreateLoadBalancerPortInput) *PortCreate

+ func (pc *PortCreate) AddPoolIDs(ids ...gidx.PrefixedID) *PortCreate

+ func (pc *PortCreate) AddPools(p ...*Pool) *PortCreate

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

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

+ func (pc *PortCreate) Mutation() *PortMutation

+ func (pc *PortCreate) Save(ctx context.Context) (*Port, error)

+ func (pc *PortCreate) SaveX(ctx context.Context) *Port

+ func (pc *PortCreate) SetCreatedAt(t time.Time) *PortCreate

+ func (pc *PortCreate) SetID(gi gidx.PrefixedID) *PortCreate

+ func (pc *PortCreate) SetLoadBalancer(l *LoadBalancer) *PortCreate

+ func (pc *PortCreate) SetLoadBalancerID(gi gidx.PrefixedID) *PortCreate

+ func (pc *PortCreate) SetName(s string) *PortCreate

+ func (pc *PortCreate) SetNillableCreatedAt(t *time.Time) *PortCreate

+ func (pc *PortCreate) SetNillableID(gi *gidx.PrefixedID) *PortCreate

+ func (pc *PortCreate) SetNillableUpdatedAt(t *time.Time) *PortCreate

+ func (pc *PortCreate) SetNumber(i int) *PortCreate

+ func (pc *PortCreate) SetUpdatedAt(t time.Time) *PortCreate

+ type PortCreateBulk struct

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

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

+ func (pcb *PortCreateBulk) Save(ctx context.Context) ([]*Port, error)

+ func (pcb *PortCreateBulk) SaveX(ctx context.Context) []*Port

+ type PortDelete struct

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

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

+ func (pd *PortDelete) Where(ps ...predicate.Port) *PortDelete

+ type PortDeleteOne struct

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

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

+ func (pdo *PortDeleteOne) Where(ps ...predicate.Port) *PortDeleteOne

+ type PortEdges struct

+ LoadBalancer *LoadBalancer

+ Pools []*Pool

+ func (e PortEdges) LoadBalancerOrErr() (*LoadBalancer, error)

+ func (e PortEdges) PoolsOrErr() ([]*Pool, error)

+ type PortGroupBy struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type PortMutation struct

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

+ func (m *PortMutation) AddNumber(i int)

+ func (m *PortMutation) AddPoolIDs(ids ...gidx.PrefixedID)

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

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

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

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

+ func (m *PortMutation) AddedNumber() (r int, exists bool)

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

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

+ func (m *PortMutation) ClearLoadBalancer()

+ func (m *PortMutation) ClearPools()

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

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

+ func (m *PortMutation) CreatedAt() (r time.Time, exists bool)

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

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

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

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

+ func (m *PortMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *PortMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

+ func (m *PortMutation) LoadBalancerCleared() bool

+ func (m *PortMutation) LoadBalancerID() (r gidx.PrefixedID, exists bool)

+ func (m *PortMutation) LoadBalancerIDs() (ids []gidx.PrefixedID)

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

+ func (m *PortMutation) Number() (r int, exists bool)

+ func (m *PortMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

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

+ func (m *PortMutation) OldLoadBalancerID(ctx context.Context) (v gidx.PrefixedID, err error)

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

+ func (m *PortMutation) OldNumber(ctx context.Context) (v int, err error)

+ func (m *PortMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *PortMutation) Op() Op

+ func (m *PortMutation) PoolsCleared() bool

+ func (m *PortMutation) PoolsIDs() (ids []gidx.PrefixedID)

+ func (m *PortMutation) RemovePoolIDs(ids ...gidx.PrefixedID)

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

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

+ func (m *PortMutation) RemovedPoolsIDs() (ids []gidx.PrefixedID)

+ func (m *PortMutation) ResetCreatedAt()

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

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

+ func (m *PortMutation) ResetLoadBalancer()

+ func (m *PortMutation) ResetLoadBalancerID()

+ func (m *PortMutation) ResetName()

+ func (m *PortMutation) ResetNumber()

+ func (m *PortMutation) ResetPools()

+ func (m *PortMutation) ResetUpdatedAt()

+ func (m *PortMutation) SetCreatedAt(t time.Time)

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

+ func (m *PortMutation) SetID(id gidx.PrefixedID)

+ func (m *PortMutation) SetLoadBalancerID(gi gidx.PrefixedID)

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

+ func (m *PortMutation) SetNumber(i int)

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

+ func (m *PortMutation) SetUpdatedAt(t time.Time)

+ func (m *PortMutation) Type() string

+ func (m *PortMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *PortMutation) Where(ps ...predicate.Port)

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

+ func (m PortMutation) Client() *Client

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

+ type PortQuery struct

+ func (po *PortQuery) CollectFields(ctx context.Context, satisfies ...string) (*PortQuery, error)

+ func (po *PortQuery) Paginate(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerPortConnection, error)

+ func (pq *PortQuery) Aggregate(fns ...AggregateFunc) *PortSelect

+ func (pq *PortQuery) All(ctx context.Context) ([]*Port, error)

+ func (pq *PortQuery) AllX(ctx context.Context) []*Port

+ func (pq *PortQuery) Clone() *PortQuery

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

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

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

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

+ func (pq *PortQuery) First(ctx context.Context) (*Port, error)

+ func (pq *PortQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *PortQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *PortQuery) FirstX(ctx context.Context) *Port

+ func (pq *PortQuery) GroupBy(field string, fields ...string) *PortGroupBy

+ func (pq *PortQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (pq *PortQuery) IDsX(ctx context.Context) []gidx.PrefixedID

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

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

+ func (pq *PortQuery) Only(ctx context.Context) (*Port, error)

+ func (pq *PortQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *PortQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *PortQuery) OnlyX(ctx context.Context) *Port

+ func (pq *PortQuery) Order(o ...port.OrderOption) *PortQuery

+ func (pq *PortQuery) QueryLoadBalancer() *LoadBalancerQuery

+ func (pq *PortQuery) QueryPools() *PoolQuery

+ func (pq *PortQuery) Select(fields ...string) *PortSelect

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

+ func (pq *PortQuery) Where(ps ...predicate.Port) *PortQuery

+ func (pq *PortQuery) WithLoadBalancer(opts ...func(*LoadBalancerQuery)) *PortQuery

+ func (pq *PortQuery) WithNamedPools(name string, opts ...func(*PoolQuery)) *PortQuery

+ func (pq *PortQuery) WithPools(opts ...func(*PoolQuery)) *PortQuery

+ type PortSelect struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type PortUpdate struct

+ func (c *PortUpdate) SetInput(i UpdateLoadBalancerPortInput) *PortUpdate

+ func (pu *PortUpdate) AddNumber(i int) *PortUpdate

+ func (pu *PortUpdate) AddPoolIDs(ids ...gidx.PrefixedID) *PortUpdate

+ func (pu *PortUpdate) AddPools(p ...*Pool) *PortUpdate

+ func (pu *PortUpdate) ClearPools() *PortUpdate

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

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

+ func (pu *PortUpdate) Mutation() *PortMutation

+ func (pu *PortUpdate) RemovePoolIDs(ids ...gidx.PrefixedID) *PortUpdate

+ func (pu *PortUpdate) RemovePools(p ...*Pool) *PortUpdate

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

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

+ func (pu *PortUpdate) SetName(s string) *PortUpdate

+ func (pu *PortUpdate) SetNumber(i int) *PortUpdate

+ func (pu *PortUpdate) Where(ps ...predicate.Port) *PortUpdate

+ type PortUpdateOne struct

+ func (c *PortUpdateOne) SetInput(i UpdateLoadBalancerPortInput) *PortUpdateOne

+ func (puo *PortUpdateOne) AddNumber(i int) *PortUpdateOne

+ func (puo *PortUpdateOne) AddPoolIDs(ids ...gidx.PrefixedID) *PortUpdateOne

+ func (puo *PortUpdateOne) AddPools(p ...*Pool) *PortUpdateOne

+ func (puo *PortUpdateOne) ClearPools() *PortUpdateOne

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

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

+ func (puo *PortUpdateOne) Mutation() *PortMutation

+ func (puo *PortUpdateOne) RemovePoolIDs(ids ...gidx.PrefixedID) *PortUpdateOne

+ func (puo *PortUpdateOne) RemovePools(p ...*Pool) *PortUpdateOne

+ func (puo *PortUpdateOne) Save(ctx context.Context) (*Port, error)

+ func (puo *PortUpdateOne) SaveX(ctx context.Context) *Port

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

+ func (puo *PortUpdateOne) SetName(s string) *PortUpdateOne

+ func (puo *PortUpdateOne) SetNumber(i int) *PortUpdateOne

+ func (puo *PortUpdateOne) Where(ps ...predicate.Port) *PortUpdateOne

+ type Ports []*Port

+ type Provider struct

+ CreatedAt time.Time

+ Edges ProviderEdges

+ ID gidx.PrefixedID

+ Name string

+ TenantID gidx.PrefixedID

+ UpdatedAt time.Time

+ func (n *Provider) IsNode()

+ func (pr *Provider) LoadBalancers(ctx context.Context, after *Cursor, first *int, before *Cursor, last *int, ...) (*LoadBalancerConnection, error)

+ func (pr *Provider) NamedLoadBalancers(name string) ([]*LoadBalancer, error)

+ func (pr *Provider) QueryLoadBalancers() *LoadBalancerQuery

+ func (pr *Provider) String() string

+ func (pr *Provider) Unwrap() *Provider

+ func (pr *Provider) Update() *ProviderUpdateOne

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

+ func (pr Provider) IsEntity()

+ type ProviderClient struct

+ func NewProviderClient(c config) *ProviderClient

+ func (c *ProviderClient) Create() *ProviderCreate

+ func (c *ProviderClient) CreateBulk(builders ...*ProviderCreate) *ProviderCreateBulk

+ func (c *ProviderClient) Delete() *ProviderDelete

+ func (c *ProviderClient) DeleteOne(pr *Provider) *ProviderDeleteOne

+ func (c *ProviderClient) DeleteOneID(id gidx.PrefixedID) *ProviderDeleteOne

+ func (c *ProviderClient) Get(ctx context.Context, id gidx.PrefixedID) (*Provider, error)

+ func (c *ProviderClient) GetX(ctx context.Context, id gidx.PrefixedID) *Provider

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

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

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

+ func (c *ProviderClient) Query() *ProviderQuery

+ func (c *ProviderClient) QueryLoadBalancers(pr *Provider) *LoadBalancerQuery

+ func (c *ProviderClient) Update() *ProviderUpdate

+ func (c *ProviderClient) UpdateOne(pr *Provider) *ProviderUpdateOne

+ func (c *ProviderClient) UpdateOneID(id gidx.PrefixedID) *ProviderUpdateOne

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

+ type ProviderCreate struct

+ func (c *ProviderCreate) SetInput(i CreateLoadBalancerProviderInput) *ProviderCreate

+ func (pc *ProviderCreate) AddLoadBalancerIDs(ids ...gidx.PrefixedID) *ProviderCreate

+ func (pc *ProviderCreate) AddLoadBalancers(l ...*LoadBalancer) *ProviderCreate

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

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

+ func (pc *ProviderCreate) Mutation() *ProviderMutation

+ func (pc *ProviderCreate) Save(ctx context.Context) (*Provider, error)

+ func (pc *ProviderCreate) SaveX(ctx context.Context) *Provider

+ func (pc *ProviderCreate) SetCreatedAt(t time.Time) *ProviderCreate

+ func (pc *ProviderCreate) SetID(gi gidx.PrefixedID) *ProviderCreate

+ func (pc *ProviderCreate) SetName(s string) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableCreatedAt(t *time.Time) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableID(gi *gidx.PrefixedID) *ProviderCreate

+ func (pc *ProviderCreate) SetNillableUpdatedAt(t *time.Time) *ProviderCreate

+ func (pc *ProviderCreate) SetTenantID(gi gidx.PrefixedID) *ProviderCreate

+ func (pc *ProviderCreate) SetUpdatedAt(t time.Time) *ProviderCreate

+ type ProviderCreateBulk struct

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

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

+ func (pcb *ProviderCreateBulk) Save(ctx context.Context) ([]*Provider, error)

+ func (pcb *ProviderCreateBulk) SaveX(ctx context.Context) []*Provider

+ type ProviderDelete struct

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

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

+ func (pd *ProviderDelete) Where(ps ...predicate.Provider) *ProviderDelete

+ type ProviderDeleteOne struct

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

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

+ func (pdo *ProviderDeleteOne) Where(ps ...predicate.Provider) *ProviderDeleteOne

+ type ProviderEdges struct

+ LoadBalancers []*LoadBalancer

+ func (e ProviderEdges) LoadBalancersOrErr() ([]*LoadBalancer, error)

+ type ProviderGroupBy struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type ProviderMutation struct

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

+ func (m *ProviderMutation) AddLoadBalancerIDs(ids ...gidx.PrefixedID)

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

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

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

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

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

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

+ func (m *ProviderMutation) ClearLoadBalancers()

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

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

+ func (m *ProviderMutation) CreatedAt() (r time.Time, exists bool)

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

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

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

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

+ func (m *ProviderMutation) ID() (id gidx.PrefixedID, exists bool)

+ func (m *ProviderMutation) IDs(ctx context.Context) ([]gidx.PrefixedID, error)

+ func (m *ProviderMutation) LoadBalancersCleared() bool

+ func (m *ProviderMutation) LoadBalancersIDs() (ids []gidx.PrefixedID)

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

+ func (m *ProviderMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error)

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

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

+ func (m *ProviderMutation) OldTenantID(ctx context.Context) (v gidx.PrefixedID, err error)

+ func (m *ProviderMutation) OldUpdatedAt(ctx context.Context) (v time.Time, err error)

+ func (m *ProviderMutation) Op() Op

+ func (m *ProviderMutation) RemoveLoadBalancerIDs(ids ...gidx.PrefixedID)

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

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

+ func (m *ProviderMutation) RemovedLoadBalancersIDs() (ids []gidx.PrefixedID)

+ func (m *ProviderMutation) ResetCreatedAt()

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

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

+ func (m *ProviderMutation) ResetLoadBalancers()

+ func (m *ProviderMutation) ResetName()

+ func (m *ProviderMutation) ResetTenantID()

+ func (m *ProviderMutation) ResetUpdatedAt()

+ func (m *ProviderMutation) SetCreatedAt(t time.Time)

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

+ func (m *ProviderMutation) SetID(id gidx.PrefixedID)

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

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

+ func (m *ProviderMutation) SetTenantID(gi gidx.PrefixedID)

+ func (m *ProviderMutation) SetUpdatedAt(t time.Time)

+ func (m *ProviderMutation) TenantID() (r gidx.PrefixedID, exists bool)

+ func (m *ProviderMutation) Type() string

+ func (m *ProviderMutation) UpdatedAt() (r time.Time, exists bool)

+ func (m *ProviderMutation) Where(ps ...predicate.Provider)

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

+ func (m ProviderMutation) Client() *Client

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

+ type ProviderQuery struct

+ func (pq *ProviderQuery) Aggregate(fns ...AggregateFunc) *ProviderSelect

+ func (pq *ProviderQuery) All(ctx context.Context) ([]*Provider, error)

+ func (pq *ProviderQuery) AllX(ctx context.Context) []*Provider

+ func (pq *ProviderQuery) Clone() *ProviderQuery

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

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

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

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

+ func (pq *ProviderQuery) First(ctx context.Context) (*Provider, error)

+ func (pq *ProviderQuery) FirstID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *ProviderQuery) FirstIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *ProviderQuery) FirstX(ctx context.Context) *Provider

+ func (pq *ProviderQuery) GroupBy(field string, fields ...string) *ProviderGroupBy

+ func (pq *ProviderQuery) IDs(ctx context.Context) (ids []gidx.PrefixedID, err error)

+ func (pq *ProviderQuery) IDsX(ctx context.Context) []gidx.PrefixedID

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

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

+ func (pq *ProviderQuery) Only(ctx context.Context) (*Provider, error)

+ func (pq *ProviderQuery) OnlyID(ctx context.Context) (id gidx.PrefixedID, err error)

+ func (pq *ProviderQuery) OnlyIDX(ctx context.Context) gidx.PrefixedID

+ func (pq *ProviderQuery) OnlyX(ctx context.Context) *Provider

+ func (pq *ProviderQuery) Order(o ...provider.OrderOption) *ProviderQuery

+ func (pq *ProviderQuery) QueryLoadBalancers() *LoadBalancerQuery

+ func (pq *ProviderQuery) Select(fields ...string) *ProviderSelect

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

+ func (pq *ProviderQuery) Where(ps ...predicate.Provider) *ProviderQuery

+ func (pq *ProviderQuery) WithLoadBalancers(opts ...func(*LoadBalancerQuery)) *ProviderQuery

+ func (pq *ProviderQuery) WithNamedLoadBalancers(name string, opts ...func(*LoadBalancerQuery)) *ProviderQuery

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

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

+ type ProviderSelect struct

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

+ type ProviderUpdate struct

+ func (c *ProviderUpdate) SetInput(i UpdateLoadBalancerProviderInput) *ProviderUpdate

+ func (pu *ProviderUpdate) AddLoadBalancerIDs(ids ...gidx.PrefixedID) *ProviderUpdate

+ func (pu *ProviderUpdate) AddLoadBalancers(l ...*LoadBalancer) *ProviderUpdate

+ func (pu *ProviderUpdate) ClearLoadBalancers() *ProviderUpdate

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

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

+ func (pu *ProviderUpdate) Mutation() *ProviderMutation

+ func (pu *ProviderUpdate) RemoveLoadBalancerIDs(ids ...gidx.PrefixedID) *ProviderUpdate

+ func (pu *ProviderUpdate) RemoveLoadBalancers(l ...*LoadBalancer) *ProviderUpdate

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

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

+ func (pu *ProviderUpdate) SetName(s string) *ProviderUpdate

+ func (pu *ProviderUpdate) Where(ps ...predicate.Provider) *ProviderUpdate

+ type ProviderUpdateOne struct

+ func (c *ProviderUpdateOne) SetInput(i UpdateLoadBalancerProviderInput) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) AddLoadBalancerIDs(ids ...gidx.PrefixedID) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) AddLoadBalancers(l ...*LoadBalancer) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) ClearLoadBalancers() *ProviderUpdateOne

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

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

+ func (puo *ProviderUpdateOne) Mutation() *ProviderMutation

+ func (puo *ProviderUpdateOne) RemoveLoadBalancerIDs(ids ...gidx.PrefixedID) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) RemoveLoadBalancers(l ...*LoadBalancer) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) Save(ctx context.Context) (*Provider, error)

+ func (puo *ProviderUpdateOne) SaveX(ctx context.Context) *Provider

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

+ func (puo *ProviderUpdateOne) SetName(s string) *ProviderUpdateOne

+ func (puo *ProviderUpdateOne) Where(ps ...predicate.Provider) *ProviderUpdateOne

+ type Providers []*Provider

+ type Querier = ent.Querier

+ type QuerierFunc = ent.QuerierFunc

+ type Query = ent.Query

+ type QueryContext = ent.QueryContext

+ 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 TraverseFunc = ent.TraverseFunc

+ type Traverser = ent.Traverser

+ type Tx struct

+ LoadBalancer *LoadBalancerClient

+ LoadBalancerAnnotation *LoadBalancerAnnotationClient

+ LoadBalancerStatus *LoadBalancerStatusClient

+ Origin *OriginClient

+ Pool *PoolClient

+ Port *PortClient

+ Provider *ProviderClient

+ 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 UpdateLoadBalancerInput struct

+ AddPortIDs []gidx.PrefixedID

+ ClearPorts bool

+ Name *string

+ RemovePortIDs []gidx.PrefixedID

+ func (i *UpdateLoadBalancerInput) Mutate(m *LoadBalancerMutation)

+ type UpdateLoadBalancerOriginInput struct

+ Active *bool

+ Name *string

+ PortNumber *int

+ Target *string

+ func (i *UpdateLoadBalancerOriginInput) Mutate(m *OriginMutation)

+ type UpdateLoadBalancerPoolInput struct

+ AddOriginIDs []gidx.PrefixedID

+ AddPortIDs []gidx.PrefixedID

+ ClearOrigins bool

+ ClearPorts bool

+ Name *string

+ Protocol *pool.Protocol

+ RemoveOriginIDs []gidx.PrefixedID

+ RemovePortIDs []gidx.PrefixedID

+ func (i *UpdateLoadBalancerPoolInput) Mutate(m *PoolMutation)

+ type UpdateLoadBalancerPortInput struct

+ AddPoolIDs []gidx.PrefixedID

+ ClearPools bool

+ Name *string

+ Number *int

+ RemovePoolIDs []gidx.PrefixedID

+ func (i *UpdateLoadBalancerPortInput) Mutate(m *PortMutation)

+ type UpdateLoadBalancerProviderInput struct

+ Name *string

+ func (i *UpdateLoadBalancerProviderInput) Mutate(m *ProviderMutation)

+ type ValidationError struct

+ Name string

+ func (e *ValidationError) Error() string

+ func (e *ValidationError) Unwrap() error

+ type Value = ent.Value

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL