Versions in this module Expand all Collapse all v0 v0.1.0 Oct 12, 2026 Changes in this version + const OpCreate + const OpDelete + const OpDeleteOne + const OpUpdate + const OpUpdateOne + const TypeDataKey + const TypeKEK + const TypeKEKVersion + const TypeSentinel + const TypeShred + var ErrTxStarted = errors.New("ent: cannot start a transaction within a transaction") + 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 + 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 + DataKey *DataKeyClient + KEK *KEKClient + KEKVersion *KEKVersionClient + Schema *migrate.Schema + Sentinel *SentinelClient + Shred *ShredClient + 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) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *Client) Intercept(interceptors ...Interceptor) + func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) + func (c *Client) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, 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 DataKey struct + Algorithm uint8 + CreatedAt time.Time + Edges DataKeyEdges + Epoch uint32 + ID envelope.ID + IsCurrent bool + KekID envelope.ID + KekVersion uint32 + Purpose string + Reserved uint64 + State uint8 + Subject string + Wrapped []byte + WrappedUnder []keyforge.KEKVersionRef + func (_m *DataKey) QueryKek() *KEKQuery + func (_m *DataKey) String() string + func (_m *DataKey) Unwrap() *DataKey + func (_m *DataKey) Update() *DataKeyUpdateOne + func (_m *DataKey) Value(name string) (ent.Value, error) + func (c *DataKey) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKey) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyClient struct + func NewDataKeyClient(c config) *DataKeyClient + func (c *DataKeyClient) Create() *DataKeyCreate + func (c *DataKeyClient) CreateBulk(builders ...*DataKeyCreate) *DataKeyCreateBulk + func (c *DataKeyClient) Delete() *DataKeyDelete + func (c *DataKeyClient) DeleteOne(_m *DataKey) *DataKeyDeleteOne + func (c *DataKeyClient) DeleteOneID(id envelope.ID) *DataKeyDeleteOne + func (c *DataKeyClient) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyClient) Get(ctx context.Context, id envelope.ID) (*DataKey, error) + func (c *DataKeyClient) GetX(ctx context.Context, id envelope.ID) *DataKey + func (c *DataKeyClient) Hooks() []Hook + func (c *DataKeyClient) Intercept(interceptors ...Interceptor) + func (c *DataKeyClient) Interceptors() []Interceptor + func (c *DataKeyClient) MapCreateBulk(slice any, setFunc func(*DataKeyCreate, int)) *DataKeyCreateBulk + func (c *DataKeyClient) Query() *DataKeyQuery + func (c *DataKeyClient) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (c *DataKeyClient) QueryKek(_m *DataKey) *KEKQuery + func (c *DataKeyClient) Update() *DataKeyUpdate + func (c *DataKeyClient) UpdateOne(_m *DataKey) *DataKeyUpdateOne + func (c *DataKeyClient) UpdateOneID(id envelope.ID) *DataKeyUpdateOne + func (c *DataKeyClient) Use(hooks ...Hook) + type DataKeyCreate struct + func (_c *DataKeyCreate) Exec(ctx context.Context) error + func (_c *DataKeyCreate) ExecX(ctx context.Context) + func (_c *DataKeyCreate) Mutation() *DataKeyMutation + func (_c *DataKeyCreate) OnConflict(opts ...sql.ConflictOption) *DataKeyUpsertOne + func (_c *DataKeyCreate) OnConflictColumns(columns ...string) *DataKeyUpsertOne + func (_c *DataKeyCreate) Save(ctx context.Context) (*DataKey, error) + func (_c *DataKeyCreate) SaveX(ctx context.Context) *DataKey + func (_c *DataKeyCreate) SetAlgorithm(v uint8) *DataKeyCreate + func (_c *DataKeyCreate) SetCreatedAt(v time.Time) *DataKeyCreate + func (_c *DataKeyCreate) SetEpoch(v uint32) *DataKeyCreate + func (_c *DataKeyCreate) SetID(v envelope.ID) *DataKeyCreate + func (_c *DataKeyCreate) SetIsCurrent(v bool) *DataKeyCreate + func (_c *DataKeyCreate) SetKek(v *KEK) *DataKeyCreate + func (_c *DataKeyCreate) SetKekID(v envelope.ID) *DataKeyCreate + func (_c *DataKeyCreate) SetKekVersion(v uint32) *DataKeyCreate + func (_c *DataKeyCreate) SetNillableIsCurrent(v *bool) *DataKeyCreate + func (_c *DataKeyCreate) SetNillableReserved(v *uint64) *DataKeyCreate + func (_c *DataKeyCreate) SetNillableSubject(v *string) *DataKeyCreate + func (_c *DataKeyCreate) SetPurpose(v string) *DataKeyCreate + func (_c *DataKeyCreate) SetReserved(v uint64) *DataKeyCreate + func (_c *DataKeyCreate) SetState(v uint8) *DataKeyCreate + func (_c *DataKeyCreate) SetSubject(v string) *DataKeyCreate + func (_c *DataKeyCreate) SetWrapped(v []byte) *DataKeyCreate + func (_c *DataKeyCreate) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyCreate + func (c *DataKeyCreate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyCreate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyCreateBulk struct + func (_c *DataKeyCreateBulk) Exec(ctx context.Context) error + func (_c *DataKeyCreateBulk) ExecX(ctx context.Context) + func (_c *DataKeyCreateBulk) OnConflict(opts ...sql.ConflictOption) *DataKeyUpsertBulk + func (_c *DataKeyCreateBulk) OnConflictColumns(columns ...string) *DataKeyUpsertBulk + func (_c *DataKeyCreateBulk) Save(ctx context.Context) ([]*DataKey, error) + func (_c *DataKeyCreateBulk) SaveX(ctx context.Context) []*DataKey + func (c *DataKeyCreateBulk) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyCreateBulk) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyDelete struct + func (_d *DataKeyDelete) Exec(ctx context.Context) (int, error) + func (_d *DataKeyDelete) ExecX(ctx context.Context) int + func (_d *DataKeyDelete) Where(ps ...predicate.DataKey) *DataKeyDelete + func (c *DataKeyDelete) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyDelete) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyDeleteOne struct + func (_d *DataKeyDeleteOne) Exec(ctx context.Context) error + func (_d *DataKeyDeleteOne) ExecX(ctx context.Context) + func (_d *DataKeyDeleteOne) Where(ps ...predicate.DataKey) *DataKeyDeleteOne + type DataKeyEdges struct + Kek *KEK + func (e DataKeyEdges) KekOrErr() (*KEK, error) + type DataKeyGroupBy struct + func (_g *DataKeyGroupBy) Aggregate(fns ...AggregateFunc) *DataKeyGroupBy + func (_g *DataKeyGroupBy) Scan(ctx context.Context, v any) error + func (s *DataKeyGroupBy) Bool(ctx context.Context) (_ bool, err error) + func (s *DataKeyGroupBy) BoolX(ctx context.Context) bool + func (s *DataKeyGroupBy) Bools(ctx context.Context) ([]bool, error) + func (s *DataKeyGroupBy) BoolsX(ctx context.Context) []bool + func (s *DataKeyGroupBy) Float64(ctx context.Context) (_ float64, err error) + func (s *DataKeyGroupBy) Float64X(ctx context.Context) float64 + func (s *DataKeyGroupBy) Float64s(ctx context.Context) ([]float64, error) + func (s *DataKeyGroupBy) Float64sX(ctx context.Context) []float64 + func (s *DataKeyGroupBy) Int(ctx context.Context) (_ int, err error) + func (s *DataKeyGroupBy) IntX(ctx context.Context) int + func (s *DataKeyGroupBy) Ints(ctx context.Context) ([]int, error) + func (s *DataKeyGroupBy) IntsX(ctx context.Context) []int + func (s *DataKeyGroupBy) ScanX(ctx context.Context, v any) + func (s *DataKeyGroupBy) String(ctx context.Context) (_ string, err error) + func (s *DataKeyGroupBy) StringX(ctx context.Context) string + func (s *DataKeyGroupBy) Strings(ctx context.Context) ([]string, error) + func (s *DataKeyGroupBy) StringsX(ctx context.Context) []string + type DataKeyMutation struct + func (c *DataKeyMutation) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyMutation) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (m *DataKeyMutation) AddAlgorithm(u int8) + func (m *DataKeyMutation) AddEpoch(u int32) + func (m *DataKeyMutation) AddField(name string, value ent.Value) error + func (m *DataKeyMutation) AddKekVersion(u int32) + func (m *DataKeyMutation) AddReserved(u int64) + func (m *DataKeyMutation) AddState(u int8) + func (m *DataKeyMutation) AddedAlgorithm() (r int8, exists bool) + func (m *DataKeyMutation) AddedEdges() []string + func (m *DataKeyMutation) AddedEpoch() (r int32, exists bool) + func (m *DataKeyMutation) AddedField(name string) (ent.Value, bool) + func (m *DataKeyMutation) AddedFields() []string + func (m *DataKeyMutation) AddedIDs(name string) []ent.Value + func (m *DataKeyMutation) AddedKekVersion() (r int32, exists bool) + func (m *DataKeyMutation) AddedReserved() (r int64, exists bool) + func (m *DataKeyMutation) AddedState() (r int8, exists bool) + func (m *DataKeyMutation) Algorithm() (r uint8, exists bool) + func (m *DataKeyMutation) AppendWrappedUnder(kvr []keyforge.KEKVersionRef) + func (m *DataKeyMutation) AppendedWrappedUnder() ([]keyforge.KEKVersionRef, bool) + func (m *DataKeyMutation) ClearEdge(name string) error + func (m *DataKeyMutation) ClearField(name string) error + func (m *DataKeyMutation) ClearKek() + func (m *DataKeyMutation) ClearWrapped() + func (m *DataKeyMutation) ClearedEdges() []string + func (m *DataKeyMutation) ClearedFields() []string + func (m *DataKeyMutation) CreatedAt() (r time.Time, exists bool) + func (m *DataKeyMutation) EdgeCleared(name string) bool + func (m *DataKeyMutation) Epoch() (r uint32, exists bool) + func (m *DataKeyMutation) Field(name string) (ent.Value, bool) + func (m *DataKeyMutation) FieldCleared(name string) bool + func (m *DataKeyMutation) Fields() []string + func (m *DataKeyMutation) ID() (id envelope.ID, exists bool) + func (m *DataKeyMutation) IDs(ctx context.Context) ([]envelope.ID, error) + func (m *DataKeyMutation) IsCurrent() (r bool, exists bool) + func (m *DataKeyMutation) KekCleared() bool + func (m *DataKeyMutation) KekID() (r envelope.ID, exists bool) + func (m *DataKeyMutation) KekIDs() (ids []envelope.ID) + func (m *DataKeyMutation) KekVersion() (r uint32, exists bool) + func (m *DataKeyMutation) OldAlgorithm(ctx context.Context) (v uint8, err error) + func (m *DataKeyMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) + func (m *DataKeyMutation) OldEpoch(ctx context.Context) (v uint32, err error) + func (m *DataKeyMutation) OldField(ctx context.Context, name string) (ent.Value, error) + func (m *DataKeyMutation) OldIsCurrent(ctx context.Context) (v bool, err error) + func (m *DataKeyMutation) OldKekID(ctx context.Context) (v envelope.ID, err error) + func (m *DataKeyMutation) OldKekVersion(ctx context.Context) (v uint32, err error) + func (m *DataKeyMutation) OldPurpose(ctx context.Context) (v string, err error) + func (m *DataKeyMutation) OldReserved(ctx context.Context) (v uint64, err error) + func (m *DataKeyMutation) OldState(ctx context.Context) (v uint8, err error) + func (m *DataKeyMutation) OldSubject(ctx context.Context) (v string, err error) + func (m *DataKeyMutation) OldWrapped(ctx context.Context) (v []byte, err error) + func (m *DataKeyMutation) OldWrappedUnder(ctx context.Context) (v []keyforge.KEKVersionRef, err error) + func (m *DataKeyMutation) Op() Op + func (m *DataKeyMutation) Purpose() (r string, exists bool) + func (m *DataKeyMutation) RemovedEdges() []string + func (m *DataKeyMutation) RemovedIDs(name string) []ent.Value + func (m *DataKeyMutation) Reserved() (r uint64, exists bool) + func (m *DataKeyMutation) ResetAlgorithm() + func (m *DataKeyMutation) ResetCreatedAt() + func (m *DataKeyMutation) ResetEdge(name string) error + func (m *DataKeyMutation) ResetEpoch() + func (m *DataKeyMutation) ResetField(name string) error + func (m *DataKeyMutation) ResetIsCurrent() + func (m *DataKeyMutation) ResetKek() + func (m *DataKeyMutation) ResetKekID() + func (m *DataKeyMutation) ResetKekVersion() + func (m *DataKeyMutation) ResetPurpose() + func (m *DataKeyMutation) ResetReserved() + func (m *DataKeyMutation) ResetState() + func (m *DataKeyMutation) ResetSubject() + func (m *DataKeyMutation) ResetWrapped() + func (m *DataKeyMutation) ResetWrappedUnder() + func (m *DataKeyMutation) SetAlgorithm(u uint8) + func (m *DataKeyMutation) SetCreatedAt(t time.Time) + func (m *DataKeyMutation) SetEpoch(u uint32) + func (m *DataKeyMutation) SetField(name string, value ent.Value) error + func (m *DataKeyMutation) SetID(id envelope.ID) + func (m *DataKeyMutation) SetIsCurrent(b bool) + func (m *DataKeyMutation) SetKekID(e envelope.ID) + func (m *DataKeyMutation) SetKekVersion(u uint32) + func (m *DataKeyMutation) SetOp(op Op) + func (m *DataKeyMutation) SetPurpose(s string) + func (m *DataKeyMutation) SetReserved(u uint64) + func (m *DataKeyMutation) SetState(u uint8) + func (m *DataKeyMutation) SetSubject(s string) + func (m *DataKeyMutation) SetWrapped(b []byte) + func (m *DataKeyMutation) SetWrappedUnder(kvr []keyforge.KEKVersionRef) + func (m *DataKeyMutation) State() (r uint8, exists bool) + func (m *DataKeyMutation) Subject() (r string, exists bool) + func (m *DataKeyMutation) Type() string + func (m *DataKeyMutation) Where(ps ...predicate.DataKey) + func (m *DataKeyMutation) WhereP(ps ...func(*sql.Selector)) + func (m *DataKeyMutation) Wrapped() (r []byte, exists bool) + func (m *DataKeyMutation) WrappedCleared() bool + func (m *DataKeyMutation) WrappedUnder() (r []keyforge.KEKVersionRef, exists bool) + func (m DataKeyMutation) Client() *Client + func (m DataKeyMutation) Tx() (*Tx, error) + type DataKeyQuery struct + func (_q *DataKeyQuery) Aggregate(fns ...AggregateFunc) *DataKeySelect + func (_q *DataKeyQuery) All(ctx context.Context) ([]*DataKey, error) + func (_q *DataKeyQuery) AllX(ctx context.Context) []*DataKey + func (_q *DataKeyQuery) Clone() *DataKeyQuery + func (_q *DataKeyQuery) Count(ctx context.Context) (int, error) + func (_q *DataKeyQuery) CountX(ctx context.Context) int + func (_q *DataKeyQuery) Exist(ctx context.Context) (bool, error) + func (_q *DataKeyQuery) ExistX(ctx context.Context) bool + func (_q *DataKeyQuery) First(ctx context.Context) (*DataKey, error) + func (_q *DataKeyQuery) FirstID(ctx context.Context) (id envelope.ID, err error) + func (_q *DataKeyQuery) FirstIDX(ctx context.Context) envelope.ID + func (_q *DataKeyQuery) FirstX(ctx context.Context) *DataKey + func (_q *DataKeyQuery) ForShare(opts ...sql.LockOption) *DataKeyQuery + func (_q *DataKeyQuery) ForUpdate(opts ...sql.LockOption) *DataKeyQuery + func (_q *DataKeyQuery) GroupBy(field string, fields ...string) *DataKeyGroupBy + func (_q *DataKeyQuery) IDs(ctx context.Context) (ids []envelope.ID, err error) + func (_q *DataKeyQuery) IDsX(ctx context.Context) []envelope.ID + func (_q *DataKeyQuery) Limit(limit int) *DataKeyQuery + func (_q *DataKeyQuery) Offset(offset int) *DataKeyQuery + func (_q *DataKeyQuery) Only(ctx context.Context) (*DataKey, error) + func (_q *DataKeyQuery) OnlyID(ctx context.Context) (id envelope.ID, err error) + func (_q *DataKeyQuery) OnlyIDX(ctx context.Context) envelope.ID + func (_q *DataKeyQuery) OnlyX(ctx context.Context) *DataKey + func (_q *DataKeyQuery) Order(o ...datakey.OrderOption) *DataKeyQuery + func (_q *DataKeyQuery) QueryKek() *KEKQuery + func (_q *DataKeyQuery) Select(fields ...string) *DataKeySelect + func (_q *DataKeyQuery) Unique(unique bool) *DataKeyQuery + func (_q *DataKeyQuery) Where(ps ...predicate.DataKey) *DataKeyQuery + func (_q *DataKeyQuery) WithKek(opts ...func(*KEKQuery)) *DataKeyQuery + func (c *DataKeyQuery) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyQuery) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeySelect struct + func (_s *DataKeySelect) Aggregate(fns ...AggregateFunc) *DataKeySelect + func (_s *DataKeySelect) Scan(ctx context.Context, v any) error + func (c DataKeySelect) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c DataKeySelect) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (s *DataKeySelect) Bool(ctx context.Context) (_ bool, err error) + func (s *DataKeySelect) BoolX(ctx context.Context) bool + func (s *DataKeySelect) Bools(ctx context.Context) ([]bool, error) + func (s *DataKeySelect) BoolsX(ctx context.Context) []bool + func (s *DataKeySelect) Float64(ctx context.Context) (_ float64, err error) + func (s *DataKeySelect) Float64X(ctx context.Context) float64 + func (s *DataKeySelect) Float64s(ctx context.Context) ([]float64, error) + func (s *DataKeySelect) Float64sX(ctx context.Context) []float64 + func (s *DataKeySelect) Int(ctx context.Context) (_ int, err error) + func (s *DataKeySelect) IntX(ctx context.Context) int + func (s *DataKeySelect) Ints(ctx context.Context) ([]int, error) + func (s *DataKeySelect) IntsX(ctx context.Context) []int + func (s *DataKeySelect) ScanX(ctx context.Context, v any) + func (s *DataKeySelect) String(ctx context.Context) (_ string, err error) + func (s *DataKeySelect) StringX(ctx context.Context) string + func (s *DataKeySelect) Strings(ctx context.Context) ([]string, error) + func (s *DataKeySelect) StringsX(ctx context.Context) []string + type DataKeyUpdate struct + func (_u *DataKeyUpdate) AddAlgorithm(v int8) *DataKeyUpdate + func (_u *DataKeyUpdate) AddEpoch(v int32) *DataKeyUpdate + func (_u *DataKeyUpdate) AddKekVersion(v int32) *DataKeyUpdate + func (_u *DataKeyUpdate) AddReserved(v int64) *DataKeyUpdate + func (_u *DataKeyUpdate) AddState(v int8) *DataKeyUpdate + func (_u *DataKeyUpdate) AppendWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpdate + func (_u *DataKeyUpdate) ClearKek() *DataKeyUpdate + func (_u *DataKeyUpdate) ClearWrapped() *DataKeyUpdate + func (_u *DataKeyUpdate) Exec(ctx context.Context) error + func (_u *DataKeyUpdate) ExecX(ctx context.Context) + func (_u *DataKeyUpdate) Mutation() *DataKeyMutation + func (_u *DataKeyUpdate) Save(ctx context.Context) (int, error) + func (_u *DataKeyUpdate) SaveX(ctx context.Context) int + func (_u *DataKeyUpdate) SetAlgorithm(v uint8) *DataKeyUpdate + func (_u *DataKeyUpdate) SetCreatedAt(v time.Time) *DataKeyUpdate + func (_u *DataKeyUpdate) SetEpoch(v uint32) *DataKeyUpdate + func (_u *DataKeyUpdate) SetIsCurrent(v bool) *DataKeyUpdate + func (_u *DataKeyUpdate) SetKek(v *KEK) *DataKeyUpdate + func (_u *DataKeyUpdate) SetKekID(v envelope.ID) *DataKeyUpdate + func (_u *DataKeyUpdate) SetKekVersion(v uint32) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableAlgorithm(v *uint8) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableCreatedAt(v *time.Time) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableEpoch(v *uint32) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableIsCurrent(v *bool) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableKekID(v *envelope.ID) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableKekVersion(v *uint32) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillablePurpose(v *string) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableReserved(v *uint64) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableState(v *uint8) *DataKeyUpdate + func (_u *DataKeyUpdate) SetNillableSubject(v *string) *DataKeyUpdate + func (_u *DataKeyUpdate) SetPurpose(v string) *DataKeyUpdate + func (_u *DataKeyUpdate) SetReserved(v uint64) *DataKeyUpdate + func (_u *DataKeyUpdate) SetState(v uint8) *DataKeyUpdate + func (_u *DataKeyUpdate) SetSubject(v string) *DataKeyUpdate + func (_u *DataKeyUpdate) SetWrapped(v []byte) *DataKeyUpdate + func (_u *DataKeyUpdate) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpdate + func (_u *DataKeyUpdate) Where(ps ...predicate.DataKey) *DataKeyUpdate + func (c *DataKeyUpdate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyUpdate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyUpdateOne struct + func (_u *DataKeyUpdateOne) AddAlgorithm(v int8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) AddEpoch(v int32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) AddKekVersion(v int32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) AddReserved(v int64) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) AddState(v int8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) AppendWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) ClearKek() *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) ClearWrapped() *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) Exec(ctx context.Context) error + func (_u *DataKeyUpdateOne) ExecX(ctx context.Context) + func (_u *DataKeyUpdateOne) Mutation() *DataKeyMutation + func (_u *DataKeyUpdateOne) Save(ctx context.Context) (*DataKey, error) + func (_u *DataKeyUpdateOne) SaveX(ctx context.Context) *DataKey + func (_u *DataKeyUpdateOne) Select(field string, fields ...string) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetAlgorithm(v uint8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetCreatedAt(v time.Time) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetEpoch(v uint32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetIsCurrent(v bool) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetKek(v *KEK) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetKekID(v envelope.ID) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetKekVersion(v uint32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableAlgorithm(v *uint8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableCreatedAt(v *time.Time) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableEpoch(v *uint32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableIsCurrent(v *bool) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableKekID(v *envelope.ID) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableKekVersion(v *uint32) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillablePurpose(v *string) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableReserved(v *uint64) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableState(v *uint8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetNillableSubject(v *string) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetPurpose(v string) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetReserved(v uint64) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetState(v uint8) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetSubject(v string) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetWrapped(v []byte) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpdateOne + func (_u *DataKeyUpdateOne) Where(ps ...predicate.DataKey) *DataKeyUpdateOne + func (c *DataKeyUpdateOne) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *DataKeyUpdateOne) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type DataKeyUpsert struct + func (u *DataKeyUpsert) AddAlgorithm(v uint8) *DataKeyUpsert + func (u *DataKeyUpsert) AddEpoch(v uint32) *DataKeyUpsert + func (u *DataKeyUpsert) AddKekVersion(v uint32) *DataKeyUpsert + func (u *DataKeyUpsert) AddReserved(v uint64) *DataKeyUpsert + func (u *DataKeyUpsert) AddState(v uint8) *DataKeyUpsert + func (u *DataKeyUpsert) ClearWrapped() *DataKeyUpsert + func (u *DataKeyUpsert) SetAlgorithm(v uint8) *DataKeyUpsert + func (u *DataKeyUpsert) SetCreatedAt(v time.Time) *DataKeyUpsert + func (u *DataKeyUpsert) SetEpoch(v uint32) *DataKeyUpsert + func (u *DataKeyUpsert) SetIsCurrent(v bool) *DataKeyUpsert + func (u *DataKeyUpsert) SetKekID(v envelope.ID) *DataKeyUpsert + func (u *DataKeyUpsert) SetKekVersion(v uint32) *DataKeyUpsert + func (u *DataKeyUpsert) SetPurpose(v string) *DataKeyUpsert + func (u *DataKeyUpsert) SetReserved(v uint64) *DataKeyUpsert + func (u *DataKeyUpsert) SetState(v uint8) *DataKeyUpsert + func (u *DataKeyUpsert) SetSubject(v string) *DataKeyUpsert + func (u *DataKeyUpsert) SetWrapped(v []byte) *DataKeyUpsert + func (u *DataKeyUpsert) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpsert + func (u *DataKeyUpsert) UpdateAlgorithm() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateCreatedAt() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateEpoch() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateIsCurrent() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateKekID() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateKekVersion() *DataKeyUpsert + func (u *DataKeyUpsert) UpdatePurpose() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateReserved() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateState() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateSubject() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateWrapped() *DataKeyUpsert + func (u *DataKeyUpsert) UpdateWrappedUnder() *DataKeyUpsert + type DataKeyUpsertBulk struct + func (u *DataKeyUpsertBulk) AddAlgorithm(v uint8) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) AddEpoch(v uint32) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) AddKekVersion(v uint32) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) AddReserved(v uint64) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) AddState(v uint8) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) ClearWrapped() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) DoNothing() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) Exec(ctx context.Context) error + func (u *DataKeyUpsertBulk) ExecX(ctx context.Context) + func (u *DataKeyUpsertBulk) Ignore() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetAlgorithm(v uint8) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetCreatedAt(v time.Time) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetEpoch(v uint32) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetIsCurrent(v bool) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetKekID(v envelope.ID) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetKekVersion(v uint32) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetPurpose(v string) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetReserved(v uint64) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetState(v uint8) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetSubject(v string) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetWrapped(v []byte) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) Update(set func(*DataKeyUpsert)) *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateAlgorithm() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateCreatedAt() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateEpoch() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateIsCurrent() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateKekID() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateKekVersion() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateNewValues() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdatePurpose() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateReserved() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateState() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateSubject() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateWrapped() *DataKeyUpsertBulk + func (u *DataKeyUpsertBulk) UpdateWrappedUnder() *DataKeyUpsertBulk + type DataKeyUpsertOne struct + func (u *DataKeyUpsertOne) AddAlgorithm(v uint8) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) AddEpoch(v uint32) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) AddKekVersion(v uint32) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) AddReserved(v uint64) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) AddState(v uint8) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) ClearWrapped() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) DoNothing() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) Exec(ctx context.Context) error + func (u *DataKeyUpsertOne) ExecX(ctx context.Context) + func (u *DataKeyUpsertOne) ID(ctx context.Context) (id envelope.ID, err error) + func (u *DataKeyUpsertOne) IDX(ctx context.Context) envelope.ID + func (u *DataKeyUpsertOne) Ignore() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetAlgorithm(v uint8) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetCreatedAt(v time.Time) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetEpoch(v uint32) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetIsCurrent(v bool) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetKekID(v envelope.ID) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetKekVersion(v uint32) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetPurpose(v string) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetReserved(v uint64) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetState(v uint8) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetSubject(v string) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetWrapped(v []byte) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) SetWrappedUnder(v []keyforge.KEKVersionRef) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) Update(set func(*DataKeyUpsert)) *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateAlgorithm() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateCreatedAt() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateEpoch() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateIsCurrent() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateKekID() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateKekVersion() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateNewValues() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdatePurpose() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateReserved() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateState() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateSubject() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateWrapped() *DataKeyUpsertOne + func (u *DataKeyUpsertOne) UpdateWrappedUnder() *DataKeyUpsertOne + type DataKeys []*DataKey + type Hook = ent.Hook + type InterceptFunc = ent.InterceptFunc + type Interceptor = ent.Interceptor + type KEK struct + CreatedAt time.Time + Edges KEKEdges + ID envelope.ID + Provider string + ProviderRef string + Purpose string + State uint8 + func (_m *KEK) QueryDataKeys() *DataKeyQuery + func (_m *KEK) QuerySentinels() *SentinelQuery + func (_m *KEK) QueryVersions() *KEKVersionQuery + func (_m *KEK) String() string + func (_m *KEK) Unwrap() *KEK + func (_m *KEK) Update() *KEKUpdateOne + func (_m *KEK) Value(name string) (ent.Value, error) + func (c *KEK) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEK) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKClient struct + func NewKEKClient(c config) *KEKClient + func (c *KEKClient) Create() *KEKCreate + func (c *KEKClient) CreateBulk(builders ...*KEKCreate) *KEKCreateBulk + func (c *KEKClient) Delete() *KEKDelete + func (c *KEKClient) DeleteOne(_m *KEK) *KEKDeleteOne + func (c *KEKClient) DeleteOneID(id envelope.ID) *KEKDeleteOne + func (c *KEKClient) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKClient) Get(ctx context.Context, id envelope.ID) (*KEK, error) + func (c *KEKClient) GetX(ctx context.Context, id envelope.ID) *KEK + func (c *KEKClient) Hooks() []Hook + func (c *KEKClient) Intercept(interceptors ...Interceptor) + func (c *KEKClient) Interceptors() []Interceptor + func (c *KEKClient) MapCreateBulk(slice any, setFunc func(*KEKCreate, int)) *KEKCreateBulk + func (c *KEKClient) Query() *KEKQuery + func (c *KEKClient) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (c *KEKClient) QueryDataKeys(_m *KEK) *DataKeyQuery + func (c *KEKClient) QuerySentinels(_m *KEK) *SentinelQuery + func (c *KEKClient) QueryVersions(_m *KEK) *KEKVersionQuery + func (c *KEKClient) Update() *KEKUpdate + func (c *KEKClient) UpdateOne(_m *KEK) *KEKUpdateOne + func (c *KEKClient) UpdateOneID(id envelope.ID) *KEKUpdateOne + func (c *KEKClient) Use(hooks ...Hook) + type KEKCreate struct + func (_c *KEKCreate) AddDataKeyIDs(ids ...envelope.ID) *KEKCreate + func (_c *KEKCreate) AddDataKeys(v ...*DataKey) *KEKCreate + func (_c *KEKCreate) AddSentinelIDs(ids ...int) *KEKCreate + func (_c *KEKCreate) AddSentinels(v ...*Sentinel) *KEKCreate + func (_c *KEKCreate) AddVersionIDs(ids ...int) *KEKCreate + func (_c *KEKCreate) AddVersions(v ...*KEKVersion) *KEKCreate + func (_c *KEKCreate) Exec(ctx context.Context) error + func (_c *KEKCreate) ExecX(ctx context.Context) + func (_c *KEKCreate) Mutation() *KEKMutation + func (_c *KEKCreate) OnConflict(opts ...sql.ConflictOption) *KEKUpsertOne + func (_c *KEKCreate) OnConflictColumns(columns ...string) *KEKUpsertOne + func (_c *KEKCreate) Save(ctx context.Context) (*KEK, error) + func (_c *KEKCreate) SaveX(ctx context.Context) *KEK + func (_c *KEKCreate) SetCreatedAt(v time.Time) *KEKCreate + func (_c *KEKCreate) SetID(v envelope.ID) *KEKCreate + func (_c *KEKCreate) SetProvider(v string) *KEKCreate + func (_c *KEKCreate) SetProviderRef(v string) *KEKCreate + func (_c *KEKCreate) SetPurpose(v string) *KEKCreate + func (_c *KEKCreate) SetState(v uint8) *KEKCreate + func (c *KEKCreate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKCreate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKCreateBulk struct + func (_c *KEKCreateBulk) Exec(ctx context.Context) error + func (_c *KEKCreateBulk) ExecX(ctx context.Context) + func (_c *KEKCreateBulk) OnConflict(opts ...sql.ConflictOption) *KEKUpsertBulk + func (_c *KEKCreateBulk) OnConflictColumns(columns ...string) *KEKUpsertBulk + func (_c *KEKCreateBulk) Save(ctx context.Context) ([]*KEK, error) + func (_c *KEKCreateBulk) SaveX(ctx context.Context) []*KEK + func (c *KEKCreateBulk) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKCreateBulk) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKDelete struct + func (_d *KEKDelete) Exec(ctx context.Context) (int, error) + func (_d *KEKDelete) ExecX(ctx context.Context) int + func (_d *KEKDelete) Where(ps ...predicate.KEK) *KEKDelete + func (c *KEKDelete) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKDelete) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKDeleteOne struct + func (_d *KEKDeleteOne) Exec(ctx context.Context) error + func (_d *KEKDeleteOne) ExecX(ctx context.Context) + func (_d *KEKDeleteOne) Where(ps ...predicate.KEK) *KEKDeleteOne + type KEKEdges struct + DataKeys []*DataKey + Sentinels []*Sentinel + Versions []*KEKVersion + func (e KEKEdges) DataKeysOrErr() ([]*DataKey, error) + func (e KEKEdges) SentinelsOrErr() ([]*Sentinel, error) + func (e KEKEdges) VersionsOrErr() ([]*KEKVersion, error) + type KEKGroupBy struct + func (_g *KEKGroupBy) Aggregate(fns ...AggregateFunc) *KEKGroupBy + func (_g *KEKGroupBy) Scan(ctx context.Context, v any) error + func (s *KEKGroupBy) Bool(ctx context.Context) (_ bool, err error) + func (s *KEKGroupBy) BoolX(ctx context.Context) bool + func (s *KEKGroupBy) Bools(ctx context.Context) ([]bool, error) + func (s *KEKGroupBy) BoolsX(ctx context.Context) []bool + func (s *KEKGroupBy) Float64(ctx context.Context) (_ float64, err error) + func (s *KEKGroupBy) Float64X(ctx context.Context) float64 + func (s *KEKGroupBy) Float64s(ctx context.Context) ([]float64, error) + func (s *KEKGroupBy) Float64sX(ctx context.Context) []float64 + func (s *KEKGroupBy) Int(ctx context.Context) (_ int, err error) + func (s *KEKGroupBy) IntX(ctx context.Context) int + func (s *KEKGroupBy) Ints(ctx context.Context) ([]int, error) + func (s *KEKGroupBy) IntsX(ctx context.Context) []int + func (s *KEKGroupBy) ScanX(ctx context.Context, v any) + func (s *KEKGroupBy) String(ctx context.Context) (_ string, err error) + func (s *KEKGroupBy) StringX(ctx context.Context) string + func (s *KEKGroupBy) Strings(ctx context.Context) ([]string, error) + func (s *KEKGroupBy) StringsX(ctx context.Context) []string + type KEKMutation struct + func (c *KEKMutation) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKMutation) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (m *KEKMutation) AddDataKeyIDs(ids ...envelope.ID) + func (m *KEKMutation) AddField(name string, value ent.Value) error + func (m *KEKMutation) AddSentinelIDs(ids ...int) + func (m *KEKMutation) AddState(u int8) + func (m *KEKMutation) AddVersionIDs(ids ...int) + func (m *KEKMutation) AddedEdges() []string + func (m *KEKMutation) AddedField(name string) (ent.Value, bool) + func (m *KEKMutation) AddedFields() []string + func (m *KEKMutation) AddedIDs(name string) []ent.Value + func (m *KEKMutation) AddedState() (r int8, exists bool) + func (m *KEKMutation) ClearDataKeys() + func (m *KEKMutation) ClearEdge(name string) error + func (m *KEKMutation) ClearField(name string) error + func (m *KEKMutation) ClearSentinels() + func (m *KEKMutation) ClearVersions() + func (m *KEKMutation) ClearedEdges() []string + func (m *KEKMutation) ClearedFields() []string + func (m *KEKMutation) CreatedAt() (r time.Time, exists bool) + func (m *KEKMutation) DataKeysCleared() bool + func (m *KEKMutation) DataKeysIDs() (ids []envelope.ID) + func (m *KEKMutation) EdgeCleared(name string) bool + func (m *KEKMutation) Field(name string) (ent.Value, bool) + func (m *KEKMutation) FieldCleared(name string) bool + func (m *KEKMutation) Fields() []string + func (m *KEKMutation) ID() (id envelope.ID, exists bool) + func (m *KEKMutation) IDs(ctx context.Context) ([]envelope.ID, error) + func (m *KEKMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) + func (m *KEKMutation) OldField(ctx context.Context, name string) (ent.Value, error) + func (m *KEKMutation) OldProvider(ctx context.Context) (v string, err error) + func (m *KEKMutation) OldProviderRef(ctx context.Context) (v string, err error) + func (m *KEKMutation) OldPurpose(ctx context.Context) (v string, err error) + func (m *KEKMutation) OldState(ctx context.Context) (v uint8, err error) + func (m *KEKMutation) Op() Op + func (m *KEKMutation) Provider() (r string, exists bool) + func (m *KEKMutation) ProviderRef() (r string, exists bool) + func (m *KEKMutation) Purpose() (r string, exists bool) + func (m *KEKMutation) RemoveDataKeyIDs(ids ...envelope.ID) + func (m *KEKMutation) RemoveSentinelIDs(ids ...int) + func (m *KEKMutation) RemoveVersionIDs(ids ...int) + func (m *KEKMutation) RemovedDataKeysIDs() (ids []envelope.ID) + func (m *KEKMutation) RemovedEdges() []string + func (m *KEKMutation) RemovedIDs(name string) []ent.Value + func (m *KEKMutation) RemovedSentinelsIDs() (ids []int) + func (m *KEKMutation) RemovedVersionsIDs() (ids []int) + func (m *KEKMutation) ResetCreatedAt() + func (m *KEKMutation) ResetDataKeys() + func (m *KEKMutation) ResetEdge(name string) error + func (m *KEKMutation) ResetField(name string) error + func (m *KEKMutation) ResetProvider() + func (m *KEKMutation) ResetProviderRef() + func (m *KEKMutation) ResetPurpose() + func (m *KEKMutation) ResetSentinels() + func (m *KEKMutation) ResetState() + func (m *KEKMutation) ResetVersions() + func (m *KEKMutation) SentinelsCleared() bool + func (m *KEKMutation) SentinelsIDs() (ids []int) + func (m *KEKMutation) SetCreatedAt(t time.Time) + func (m *KEKMutation) SetField(name string, value ent.Value) error + func (m *KEKMutation) SetID(id envelope.ID) + func (m *KEKMutation) SetOp(op Op) + func (m *KEKMutation) SetProvider(s string) + func (m *KEKMutation) SetProviderRef(s string) + func (m *KEKMutation) SetPurpose(s string) + func (m *KEKMutation) SetState(u uint8) + func (m *KEKMutation) State() (r uint8, exists bool) + func (m *KEKMutation) Type() string + func (m *KEKMutation) VersionsCleared() bool + func (m *KEKMutation) VersionsIDs() (ids []int) + func (m *KEKMutation) Where(ps ...predicate.KEK) + func (m *KEKMutation) WhereP(ps ...func(*sql.Selector)) + func (m KEKMutation) Client() *Client + func (m KEKMutation) Tx() (*Tx, error) + type KEKQuery struct + func (_q *KEKQuery) Aggregate(fns ...AggregateFunc) *KEKSelect + func (_q *KEKQuery) All(ctx context.Context) ([]*KEK, error) + func (_q *KEKQuery) AllX(ctx context.Context) []*KEK + func (_q *KEKQuery) Clone() *KEKQuery + func (_q *KEKQuery) Count(ctx context.Context) (int, error) + func (_q *KEKQuery) CountX(ctx context.Context) int + func (_q *KEKQuery) Exist(ctx context.Context) (bool, error) + func (_q *KEKQuery) ExistX(ctx context.Context) bool + func (_q *KEKQuery) First(ctx context.Context) (*KEK, error) + func (_q *KEKQuery) FirstID(ctx context.Context) (id envelope.ID, err error) + func (_q *KEKQuery) FirstIDX(ctx context.Context) envelope.ID + func (_q *KEKQuery) FirstX(ctx context.Context) *KEK + func (_q *KEKQuery) ForShare(opts ...sql.LockOption) *KEKQuery + func (_q *KEKQuery) ForUpdate(opts ...sql.LockOption) *KEKQuery + func (_q *KEKQuery) GroupBy(field string, fields ...string) *KEKGroupBy + func (_q *KEKQuery) IDs(ctx context.Context) (ids []envelope.ID, err error) + func (_q *KEKQuery) IDsX(ctx context.Context) []envelope.ID + func (_q *KEKQuery) Limit(limit int) *KEKQuery + func (_q *KEKQuery) Offset(offset int) *KEKQuery + func (_q *KEKQuery) Only(ctx context.Context) (*KEK, error) + func (_q *KEKQuery) OnlyID(ctx context.Context) (id envelope.ID, err error) + func (_q *KEKQuery) OnlyIDX(ctx context.Context) envelope.ID + func (_q *KEKQuery) OnlyX(ctx context.Context) *KEK + func (_q *KEKQuery) Order(o ...kek.OrderOption) *KEKQuery + func (_q *KEKQuery) QueryDataKeys() *DataKeyQuery + func (_q *KEKQuery) QuerySentinels() *SentinelQuery + func (_q *KEKQuery) QueryVersions() *KEKVersionQuery + func (_q *KEKQuery) Select(fields ...string) *KEKSelect + func (_q *KEKQuery) Unique(unique bool) *KEKQuery + func (_q *KEKQuery) Where(ps ...predicate.KEK) *KEKQuery + func (_q *KEKQuery) WithDataKeys(opts ...func(*DataKeyQuery)) *KEKQuery + func (_q *KEKQuery) WithSentinels(opts ...func(*SentinelQuery)) *KEKQuery + func (_q *KEKQuery) WithVersions(opts ...func(*KEKVersionQuery)) *KEKQuery + func (c *KEKQuery) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKQuery) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKSelect struct + func (_s *KEKSelect) Aggregate(fns ...AggregateFunc) *KEKSelect + func (_s *KEKSelect) Scan(ctx context.Context, v any) error + func (c KEKSelect) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c KEKSelect) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (s *KEKSelect) Bool(ctx context.Context) (_ bool, err error) + func (s *KEKSelect) BoolX(ctx context.Context) bool + func (s *KEKSelect) Bools(ctx context.Context) ([]bool, error) + func (s *KEKSelect) BoolsX(ctx context.Context) []bool + func (s *KEKSelect) Float64(ctx context.Context) (_ float64, err error) + func (s *KEKSelect) Float64X(ctx context.Context) float64 + func (s *KEKSelect) Float64s(ctx context.Context) ([]float64, error) + func (s *KEKSelect) Float64sX(ctx context.Context) []float64 + func (s *KEKSelect) Int(ctx context.Context) (_ int, err error) + func (s *KEKSelect) IntX(ctx context.Context) int + func (s *KEKSelect) Ints(ctx context.Context) ([]int, error) + func (s *KEKSelect) IntsX(ctx context.Context) []int + func (s *KEKSelect) ScanX(ctx context.Context, v any) + func (s *KEKSelect) String(ctx context.Context) (_ string, err error) + func (s *KEKSelect) StringX(ctx context.Context) string + func (s *KEKSelect) Strings(ctx context.Context) ([]string, error) + func (s *KEKSelect) StringsX(ctx context.Context) []string + type KEKUpdate struct + func (_u *KEKUpdate) AddDataKeyIDs(ids ...envelope.ID) *KEKUpdate + func (_u *KEKUpdate) AddDataKeys(v ...*DataKey) *KEKUpdate + func (_u *KEKUpdate) AddSentinelIDs(ids ...int) *KEKUpdate + func (_u *KEKUpdate) AddSentinels(v ...*Sentinel) *KEKUpdate + func (_u *KEKUpdate) AddState(v int8) *KEKUpdate + func (_u *KEKUpdate) AddVersionIDs(ids ...int) *KEKUpdate + func (_u *KEKUpdate) AddVersions(v ...*KEKVersion) *KEKUpdate + func (_u *KEKUpdate) ClearDataKeys() *KEKUpdate + func (_u *KEKUpdate) ClearSentinels() *KEKUpdate + func (_u *KEKUpdate) ClearVersions() *KEKUpdate + func (_u *KEKUpdate) Exec(ctx context.Context) error + func (_u *KEKUpdate) ExecX(ctx context.Context) + func (_u *KEKUpdate) Mutation() *KEKMutation + func (_u *KEKUpdate) RemoveDataKeyIDs(ids ...envelope.ID) *KEKUpdate + func (_u *KEKUpdate) RemoveDataKeys(v ...*DataKey) *KEKUpdate + func (_u *KEKUpdate) RemoveSentinelIDs(ids ...int) *KEKUpdate + func (_u *KEKUpdate) RemoveSentinels(v ...*Sentinel) *KEKUpdate + func (_u *KEKUpdate) RemoveVersionIDs(ids ...int) *KEKUpdate + func (_u *KEKUpdate) RemoveVersions(v ...*KEKVersion) *KEKUpdate + func (_u *KEKUpdate) Save(ctx context.Context) (int, error) + func (_u *KEKUpdate) SaveX(ctx context.Context) int + func (_u *KEKUpdate) SetCreatedAt(v time.Time) *KEKUpdate + func (_u *KEKUpdate) SetNillableCreatedAt(v *time.Time) *KEKUpdate + func (_u *KEKUpdate) SetNillableProvider(v *string) *KEKUpdate + func (_u *KEKUpdate) SetNillableProviderRef(v *string) *KEKUpdate + func (_u *KEKUpdate) SetNillablePurpose(v *string) *KEKUpdate + func (_u *KEKUpdate) SetNillableState(v *uint8) *KEKUpdate + func (_u *KEKUpdate) SetProvider(v string) *KEKUpdate + func (_u *KEKUpdate) SetProviderRef(v string) *KEKUpdate + func (_u *KEKUpdate) SetPurpose(v string) *KEKUpdate + func (_u *KEKUpdate) SetState(v uint8) *KEKUpdate + func (_u *KEKUpdate) Where(ps ...predicate.KEK) *KEKUpdate + func (c *KEKUpdate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKUpdate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKUpdateOne struct + func (_u *KEKUpdateOne) AddDataKeyIDs(ids ...envelope.ID) *KEKUpdateOne + func (_u *KEKUpdateOne) AddDataKeys(v ...*DataKey) *KEKUpdateOne + func (_u *KEKUpdateOne) AddSentinelIDs(ids ...int) *KEKUpdateOne + func (_u *KEKUpdateOne) AddSentinels(v ...*Sentinel) *KEKUpdateOne + func (_u *KEKUpdateOne) AddState(v int8) *KEKUpdateOne + func (_u *KEKUpdateOne) AddVersionIDs(ids ...int) *KEKUpdateOne + func (_u *KEKUpdateOne) AddVersions(v ...*KEKVersion) *KEKUpdateOne + func (_u *KEKUpdateOne) ClearDataKeys() *KEKUpdateOne + func (_u *KEKUpdateOne) ClearSentinels() *KEKUpdateOne + func (_u *KEKUpdateOne) ClearVersions() *KEKUpdateOne + func (_u *KEKUpdateOne) Exec(ctx context.Context) error + func (_u *KEKUpdateOne) ExecX(ctx context.Context) + func (_u *KEKUpdateOne) Mutation() *KEKMutation + func (_u *KEKUpdateOne) RemoveDataKeyIDs(ids ...envelope.ID) *KEKUpdateOne + func (_u *KEKUpdateOne) RemoveDataKeys(v ...*DataKey) *KEKUpdateOne + func (_u *KEKUpdateOne) RemoveSentinelIDs(ids ...int) *KEKUpdateOne + func (_u *KEKUpdateOne) RemoveSentinels(v ...*Sentinel) *KEKUpdateOne + func (_u *KEKUpdateOne) RemoveVersionIDs(ids ...int) *KEKUpdateOne + func (_u *KEKUpdateOne) RemoveVersions(v ...*KEKVersion) *KEKUpdateOne + func (_u *KEKUpdateOne) Save(ctx context.Context) (*KEK, error) + func (_u *KEKUpdateOne) SaveX(ctx context.Context) *KEK + func (_u *KEKUpdateOne) Select(field string, fields ...string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetCreatedAt(v time.Time) *KEKUpdateOne + func (_u *KEKUpdateOne) SetNillableCreatedAt(v *time.Time) *KEKUpdateOne + func (_u *KEKUpdateOne) SetNillableProvider(v *string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetNillableProviderRef(v *string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetNillablePurpose(v *string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetNillableState(v *uint8) *KEKUpdateOne + func (_u *KEKUpdateOne) SetProvider(v string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetProviderRef(v string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetPurpose(v string) *KEKUpdateOne + func (_u *KEKUpdateOne) SetState(v uint8) *KEKUpdateOne + func (_u *KEKUpdateOne) Where(ps ...predicate.KEK) *KEKUpdateOne + func (c *KEKUpdateOne) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKUpdateOne) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKUpsert struct + func (u *KEKUpsert) AddState(v uint8) *KEKUpsert + func (u *KEKUpsert) SetCreatedAt(v time.Time) *KEKUpsert + func (u *KEKUpsert) SetProvider(v string) *KEKUpsert + func (u *KEKUpsert) SetProviderRef(v string) *KEKUpsert + func (u *KEKUpsert) SetPurpose(v string) *KEKUpsert + func (u *KEKUpsert) SetState(v uint8) *KEKUpsert + func (u *KEKUpsert) UpdateCreatedAt() *KEKUpsert + func (u *KEKUpsert) UpdateProvider() *KEKUpsert + func (u *KEKUpsert) UpdateProviderRef() *KEKUpsert + func (u *KEKUpsert) UpdatePurpose() *KEKUpsert + func (u *KEKUpsert) UpdateState() *KEKUpsert + type KEKUpsertBulk struct + func (u *KEKUpsertBulk) AddState(v uint8) *KEKUpsertBulk + func (u *KEKUpsertBulk) DoNothing() *KEKUpsertBulk + func (u *KEKUpsertBulk) Exec(ctx context.Context) error + func (u *KEKUpsertBulk) ExecX(ctx context.Context) + func (u *KEKUpsertBulk) Ignore() *KEKUpsertBulk + func (u *KEKUpsertBulk) SetCreatedAt(v time.Time) *KEKUpsertBulk + func (u *KEKUpsertBulk) SetProvider(v string) *KEKUpsertBulk + func (u *KEKUpsertBulk) SetProviderRef(v string) *KEKUpsertBulk + func (u *KEKUpsertBulk) SetPurpose(v string) *KEKUpsertBulk + func (u *KEKUpsertBulk) SetState(v uint8) *KEKUpsertBulk + func (u *KEKUpsertBulk) Update(set func(*KEKUpsert)) *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdateCreatedAt() *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdateNewValues() *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdateProvider() *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdateProviderRef() *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdatePurpose() *KEKUpsertBulk + func (u *KEKUpsertBulk) UpdateState() *KEKUpsertBulk + type KEKUpsertOne struct + func (u *KEKUpsertOne) AddState(v uint8) *KEKUpsertOne + func (u *KEKUpsertOne) DoNothing() *KEKUpsertOne + func (u *KEKUpsertOne) Exec(ctx context.Context) error + func (u *KEKUpsertOne) ExecX(ctx context.Context) + func (u *KEKUpsertOne) ID(ctx context.Context) (id envelope.ID, err error) + func (u *KEKUpsertOne) IDX(ctx context.Context) envelope.ID + func (u *KEKUpsertOne) Ignore() *KEKUpsertOne + func (u *KEKUpsertOne) SetCreatedAt(v time.Time) *KEKUpsertOne + func (u *KEKUpsertOne) SetProvider(v string) *KEKUpsertOne + func (u *KEKUpsertOne) SetProviderRef(v string) *KEKUpsertOne + func (u *KEKUpsertOne) SetPurpose(v string) *KEKUpsertOne + func (u *KEKUpsertOne) SetState(v uint8) *KEKUpsertOne + func (u *KEKUpsertOne) Update(set func(*KEKUpsert)) *KEKUpsertOne + func (u *KEKUpsertOne) UpdateCreatedAt() *KEKUpsertOne + func (u *KEKUpsertOne) UpdateNewValues() *KEKUpsertOne + func (u *KEKUpsertOne) UpdateProvider() *KEKUpsertOne + func (u *KEKUpsertOne) UpdateProviderRef() *KEKUpsertOne + func (u *KEKUpsertOne) UpdatePurpose() *KEKUpsertOne + func (u *KEKUpsertOne) UpdateState() *KEKUpsertOne + type KEKVersion struct + ActivatedAt *time.Time + CreatedAt time.Time + Edges KEKVersionEdges + ID int + KekID envelope.ID + ProviderRef string + RetireAfter *time.Time + RotatedAt *time.Time + State uint8 + Version uint32 + func (_m *KEKVersion) QueryKek() *KEKQuery + func (_m *KEKVersion) String() string + func (_m *KEKVersion) Unwrap() *KEKVersion + func (_m *KEKVersion) Update() *KEKVersionUpdateOne + func (_m *KEKVersion) Value(name string) (ent.Value, error) + func (c *KEKVersion) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersion) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionClient struct + func NewKEKVersionClient(c config) *KEKVersionClient + func (c *KEKVersionClient) Create() *KEKVersionCreate + func (c *KEKVersionClient) CreateBulk(builders ...*KEKVersionCreate) *KEKVersionCreateBulk + func (c *KEKVersionClient) Delete() *KEKVersionDelete + func (c *KEKVersionClient) DeleteOne(_m *KEKVersion) *KEKVersionDeleteOne + func (c *KEKVersionClient) DeleteOneID(id int) *KEKVersionDeleteOne + func (c *KEKVersionClient) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionClient) Get(ctx context.Context, id int) (*KEKVersion, error) + func (c *KEKVersionClient) GetX(ctx context.Context, id int) *KEKVersion + func (c *KEKVersionClient) Hooks() []Hook + func (c *KEKVersionClient) Intercept(interceptors ...Interceptor) + func (c *KEKVersionClient) Interceptors() []Interceptor + func (c *KEKVersionClient) MapCreateBulk(slice any, setFunc func(*KEKVersionCreate, int)) *KEKVersionCreateBulk + func (c *KEKVersionClient) Query() *KEKVersionQuery + func (c *KEKVersionClient) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (c *KEKVersionClient) QueryKek(_m *KEKVersion) *KEKQuery + func (c *KEKVersionClient) Update() *KEKVersionUpdate + func (c *KEKVersionClient) UpdateOne(_m *KEKVersion) *KEKVersionUpdateOne + func (c *KEKVersionClient) UpdateOneID(id int) *KEKVersionUpdateOne + func (c *KEKVersionClient) Use(hooks ...Hook) + type KEKVersionCreate struct + func (_c *KEKVersionCreate) Exec(ctx context.Context) error + func (_c *KEKVersionCreate) ExecX(ctx context.Context) + func (_c *KEKVersionCreate) Mutation() *KEKVersionMutation + func (_c *KEKVersionCreate) OnConflict(opts ...sql.ConflictOption) *KEKVersionUpsertOne + func (_c *KEKVersionCreate) OnConflictColumns(columns ...string) *KEKVersionUpsertOne + func (_c *KEKVersionCreate) Save(ctx context.Context) (*KEKVersion, error) + func (_c *KEKVersionCreate) SaveX(ctx context.Context) *KEKVersion + func (_c *KEKVersionCreate) SetActivatedAt(v time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetCreatedAt(v time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetKek(v *KEK) *KEKVersionCreate + func (_c *KEKVersionCreate) SetKekID(v envelope.ID) *KEKVersionCreate + func (_c *KEKVersionCreate) SetNillableActivatedAt(v *time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetNillableProviderRef(v *string) *KEKVersionCreate + func (_c *KEKVersionCreate) SetNillableRetireAfter(v *time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetNillableRotatedAt(v *time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetProviderRef(v string) *KEKVersionCreate + func (_c *KEKVersionCreate) SetRetireAfter(v time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetRotatedAt(v time.Time) *KEKVersionCreate + func (_c *KEKVersionCreate) SetState(v uint8) *KEKVersionCreate + func (_c *KEKVersionCreate) SetVersion(v uint32) *KEKVersionCreate + func (c *KEKVersionCreate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionCreate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionCreateBulk struct + func (_c *KEKVersionCreateBulk) Exec(ctx context.Context) error + func (_c *KEKVersionCreateBulk) ExecX(ctx context.Context) + func (_c *KEKVersionCreateBulk) OnConflict(opts ...sql.ConflictOption) *KEKVersionUpsertBulk + func (_c *KEKVersionCreateBulk) OnConflictColumns(columns ...string) *KEKVersionUpsertBulk + func (_c *KEKVersionCreateBulk) Save(ctx context.Context) ([]*KEKVersion, error) + func (_c *KEKVersionCreateBulk) SaveX(ctx context.Context) []*KEKVersion + func (c *KEKVersionCreateBulk) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionCreateBulk) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionDelete struct + func (_d *KEKVersionDelete) Exec(ctx context.Context) (int, error) + func (_d *KEKVersionDelete) ExecX(ctx context.Context) int + func (_d *KEKVersionDelete) Where(ps ...predicate.KEKVersion) *KEKVersionDelete + func (c *KEKVersionDelete) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionDelete) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionDeleteOne struct + func (_d *KEKVersionDeleteOne) Exec(ctx context.Context) error + func (_d *KEKVersionDeleteOne) ExecX(ctx context.Context) + func (_d *KEKVersionDeleteOne) Where(ps ...predicate.KEKVersion) *KEKVersionDeleteOne + type KEKVersionEdges struct + Kek *KEK + func (e KEKVersionEdges) KekOrErr() (*KEK, error) + type KEKVersionGroupBy struct + func (_g *KEKVersionGroupBy) Aggregate(fns ...AggregateFunc) *KEKVersionGroupBy + func (_g *KEKVersionGroupBy) Scan(ctx context.Context, v any) error + func (s *KEKVersionGroupBy) Bool(ctx context.Context) (_ bool, err error) + func (s *KEKVersionGroupBy) BoolX(ctx context.Context) bool + func (s *KEKVersionGroupBy) Bools(ctx context.Context) ([]bool, error) + func (s *KEKVersionGroupBy) BoolsX(ctx context.Context) []bool + func (s *KEKVersionGroupBy) Float64(ctx context.Context) (_ float64, err error) + func (s *KEKVersionGroupBy) Float64X(ctx context.Context) float64 + func (s *KEKVersionGroupBy) Float64s(ctx context.Context) ([]float64, error) + func (s *KEKVersionGroupBy) Float64sX(ctx context.Context) []float64 + func (s *KEKVersionGroupBy) Int(ctx context.Context) (_ int, err error) + func (s *KEKVersionGroupBy) IntX(ctx context.Context) int + func (s *KEKVersionGroupBy) Ints(ctx context.Context) ([]int, error) + func (s *KEKVersionGroupBy) IntsX(ctx context.Context) []int + func (s *KEKVersionGroupBy) ScanX(ctx context.Context, v any) + func (s *KEKVersionGroupBy) String(ctx context.Context) (_ string, err error) + func (s *KEKVersionGroupBy) StringX(ctx context.Context) string + func (s *KEKVersionGroupBy) Strings(ctx context.Context) ([]string, error) + func (s *KEKVersionGroupBy) StringsX(ctx context.Context) []string + type KEKVersionMutation struct + func (c *KEKVersionMutation) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionMutation) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (m *KEKVersionMutation) ActivatedAt() (r time.Time, exists bool) + func (m *KEKVersionMutation) ActivatedAtCleared() bool + func (m *KEKVersionMutation) AddField(name string, value ent.Value) error + func (m *KEKVersionMutation) AddState(u int8) + func (m *KEKVersionMutation) AddVersion(u int32) + func (m *KEKVersionMutation) AddedEdges() []string + func (m *KEKVersionMutation) AddedField(name string) (ent.Value, bool) + func (m *KEKVersionMutation) AddedFields() []string + func (m *KEKVersionMutation) AddedIDs(name string) []ent.Value + func (m *KEKVersionMutation) AddedState() (r int8, exists bool) + func (m *KEKVersionMutation) AddedVersion() (r int32, exists bool) + func (m *KEKVersionMutation) ClearActivatedAt() + func (m *KEKVersionMutation) ClearEdge(name string) error + func (m *KEKVersionMutation) ClearField(name string) error + func (m *KEKVersionMutation) ClearKek() + func (m *KEKVersionMutation) ClearRetireAfter() + func (m *KEKVersionMutation) ClearRotatedAt() + func (m *KEKVersionMutation) ClearedEdges() []string + func (m *KEKVersionMutation) ClearedFields() []string + func (m *KEKVersionMutation) CreatedAt() (r time.Time, exists bool) + func (m *KEKVersionMutation) EdgeCleared(name string) bool + func (m *KEKVersionMutation) Field(name string) (ent.Value, bool) + func (m *KEKVersionMutation) FieldCleared(name string) bool + func (m *KEKVersionMutation) Fields() []string + func (m *KEKVersionMutation) ID() (id int, exists bool) + func (m *KEKVersionMutation) IDs(ctx context.Context) ([]int, error) + func (m *KEKVersionMutation) KekCleared() bool + func (m *KEKVersionMutation) KekID() (r envelope.ID, exists bool) + func (m *KEKVersionMutation) KekIDs() (ids []envelope.ID) + func (m *KEKVersionMutation) OldActivatedAt(ctx context.Context) (v *time.Time, err error) + func (m *KEKVersionMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) + func (m *KEKVersionMutation) OldField(ctx context.Context, name string) (ent.Value, error) + func (m *KEKVersionMutation) OldKekID(ctx context.Context) (v envelope.ID, err error) + func (m *KEKVersionMutation) OldProviderRef(ctx context.Context) (v string, err error) + func (m *KEKVersionMutation) OldRetireAfter(ctx context.Context) (v *time.Time, err error) + func (m *KEKVersionMutation) OldRotatedAt(ctx context.Context) (v *time.Time, err error) + func (m *KEKVersionMutation) OldState(ctx context.Context) (v uint8, err error) + func (m *KEKVersionMutation) OldVersion(ctx context.Context) (v uint32, err error) + func (m *KEKVersionMutation) Op() Op + func (m *KEKVersionMutation) ProviderRef() (r string, exists bool) + func (m *KEKVersionMutation) RemovedEdges() []string + func (m *KEKVersionMutation) RemovedIDs(name string) []ent.Value + func (m *KEKVersionMutation) ResetActivatedAt() + func (m *KEKVersionMutation) ResetCreatedAt() + func (m *KEKVersionMutation) ResetEdge(name string) error + func (m *KEKVersionMutation) ResetField(name string) error + func (m *KEKVersionMutation) ResetKek() + func (m *KEKVersionMutation) ResetKekID() + func (m *KEKVersionMutation) ResetProviderRef() + func (m *KEKVersionMutation) ResetRetireAfter() + func (m *KEKVersionMutation) ResetRotatedAt() + func (m *KEKVersionMutation) ResetState() + func (m *KEKVersionMutation) ResetVersion() + func (m *KEKVersionMutation) RetireAfter() (r time.Time, exists bool) + func (m *KEKVersionMutation) RetireAfterCleared() bool + func (m *KEKVersionMutation) RotatedAt() (r time.Time, exists bool) + func (m *KEKVersionMutation) RotatedAtCleared() bool + func (m *KEKVersionMutation) SetActivatedAt(t time.Time) + func (m *KEKVersionMutation) SetCreatedAt(t time.Time) + func (m *KEKVersionMutation) SetField(name string, value ent.Value) error + func (m *KEKVersionMutation) SetKekID(e envelope.ID) + func (m *KEKVersionMutation) SetOp(op Op) + func (m *KEKVersionMutation) SetProviderRef(s string) + func (m *KEKVersionMutation) SetRetireAfter(t time.Time) + func (m *KEKVersionMutation) SetRotatedAt(t time.Time) + func (m *KEKVersionMutation) SetState(u uint8) + func (m *KEKVersionMutation) SetVersion(u uint32) + func (m *KEKVersionMutation) State() (r uint8, exists bool) + func (m *KEKVersionMutation) Type() string + func (m *KEKVersionMutation) Version() (r uint32, exists bool) + func (m *KEKVersionMutation) Where(ps ...predicate.KEKVersion) + func (m *KEKVersionMutation) WhereP(ps ...func(*sql.Selector)) + func (m KEKVersionMutation) Client() *Client + func (m KEKVersionMutation) Tx() (*Tx, error) + type KEKVersionQuery struct + func (_q *KEKVersionQuery) Aggregate(fns ...AggregateFunc) *KEKVersionSelect + func (_q *KEKVersionQuery) All(ctx context.Context) ([]*KEKVersion, error) + func (_q *KEKVersionQuery) AllX(ctx context.Context) []*KEKVersion + func (_q *KEKVersionQuery) Clone() *KEKVersionQuery + func (_q *KEKVersionQuery) Count(ctx context.Context) (int, error) + func (_q *KEKVersionQuery) CountX(ctx context.Context) int + func (_q *KEKVersionQuery) Exist(ctx context.Context) (bool, error) + func (_q *KEKVersionQuery) ExistX(ctx context.Context) bool + func (_q *KEKVersionQuery) First(ctx context.Context) (*KEKVersion, error) + func (_q *KEKVersionQuery) FirstID(ctx context.Context) (id int, err error) + func (_q *KEKVersionQuery) FirstIDX(ctx context.Context) int + func (_q *KEKVersionQuery) FirstX(ctx context.Context) *KEKVersion + func (_q *KEKVersionQuery) ForShare(opts ...sql.LockOption) *KEKVersionQuery + func (_q *KEKVersionQuery) ForUpdate(opts ...sql.LockOption) *KEKVersionQuery + func (_q *KEKVersionQuery) GroupBy(field string, fields ...string) *KEKVersionGroupBy + func (_q *KEKVersionQuery) IDs(ctx context.Context) (ids []int, err error) + func (_q *KEKVersionQuery) IDsX(ctx context.Context) []int + func (_q *KEKVersionQuery) Limit(limit int) *KEKVersionQuery + func (_q *KEKVersionQuery) Offset(offset int) *KEKVersionQuery + func (_q *KEKVersionQuery) Only(ctx context.Context) (*KEKVersion, error) + func (_q *KEKVersionQuery) OnlyID(ctx context.Context) (id int, err error) + func (_q *KEKVersionQuery) OnlyIDX(ctx context.Context) int + func (_q *KEKVersionQuery) OnlyX(ctx context.Context) *KEKVersion + func (_q *KEKVersionQuery) Order(o ...kekversion.OrderOption) *KEKVersionQuery + func (_q *KEKVersionQuery) QueryKek() *KEKQuery + func (_q *KEKVersionQuery) Select(fields ...string) *KEKVersionSelect + func (_q *KEKVersionQuery) Unique(unique bool) *KEKVersionQuery + func (_q *KEKVersionQuery) Where(ps ...predicate.KEKVersion) *KEKVersionQuery + func (_q *KEKVersionQuery) WithKek(opts ...func(*KEKQuery)) *KEKVersionQuery + func (c *KEKVersionQuery) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionQuery) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionSelect struct + func (_s *KEKVersionSelect) Aggregate(fns ...AggregateFunc) *KEKVersionSelect + func (_s *KEKVersionSelect) Scan(ctx context.Context, v any) error + func (c KEKVersionSelect) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c KEKVersionSelect) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (s *KEKVersionSelect) Bool(ctx context.Context) (_ bool, err error) + func (s *KEKVersionSelect) BoolX(ctx context.Context) bool + func (s *KEKVersionSelect) Bools(ctx context.Context) ([]bool, error) + func (s *KEKVersionSelect) BoolsX(ctx context.Context) []bool + func (s *KEKVersionSelect) Float64(ctx context.Context) (_ float64, err error) + func (s *KEKVersionSelect) Float64X(ctx context.Context) float64 + func (s *KEKVersionSelect) Float64s(ctx context.Context) ([]float64, error) + func (s *KEKVersionSelect) Float64sX(ctx context.Context) []float64 + func (s *KEKVersionSelect) Int(ctx context.Context) (_ int, err error) + func (s *KEKVersionSelect) IntX(ctx context.Context) int + func (s *KEKVersionSelect) Ints(ctx context.Context) ([]int, error) + func (s *KEKVersionSelect) IntsX(ctx context.Context) []int + func (s *KEKVersionSelect) ScanX(ctx context.Context, v any) + func (s *KEKVersionSelect) String(ctx context.Context) (_ string, err error) + func (s *KEKVersionSelect) StringX(ctx context.Context) string + func (s *KEKVersionSelect) Strings(ctx context.Context) ([]string, error) + func (s *KEKVersionSelect) StringsX(ctx context.Context) []string + type KEKVersionUpdate struct + func (_u *KEKVersionUpdate) AddState(v int8) *KEKVersionUpdate + func (_u *KEKVersionUpdate) AddVersion(v int32) *KEKVersionUpdate + func (_u *KEKVersionUpdate) ClearActivatedAt() *KEKVersionUpdate + func (_u *KEKVersionUpdate) ClearKek() *KEKVersionUpdate + func (_u *KEKVersionUpdate) ClearRetireAfter() *KEKVersionUpdate + func (_u *KEKVersionUpdate) ClearRotatedAt() *KEKVersionUpdate + func (_u *KEKVersionUpdate) Exec(ctx context.Context) error + func (_u *KEKVersionUpdate) ExecX(ctx context.Context) + func (_u *KEKVersionUpdate) Mutation() *KEKVersionMutation + func (_u *KEKVersionUpdate) Save(ctx context.Context) (int, error) + func (_u *KEKVersionUpdate) SaveX(ctx context.Context) int + func (_u *KEKVersionUpdate) SetActivatedAt(v time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetCreatedAt(v time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetKek(v *KEK) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetKekID(v envelope.ID) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableActivatedAt(v *time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableCreatedAt(v *time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableKekID(v *envelope.ID) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableProviderRef(v *string) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableRetireAfter(v *time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableRotatedAt(v *time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableState(v *uint8) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetNillableVersion(v *uint32) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetProviderRef(v string) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetRetireAfter(v time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetRotatedAt(v time.Time) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetState(v uint8) *KEKVersionUpdate + func (_u *KEKVersionUpdate) SetVersion(v uint32) *KEKVersionUpdate + func (_u *KEKVersionUpdate) Where(ps ...predicate.KEKVersion) *KEKVersionUpdate + func (c *KEKVersionUpdate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionUpdate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionUpdateOne struct + func (_u *KEKVersionUpdateOne) AddState(v int8) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) AddVersion(v int32) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) ClearActivatedAt() *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) ClearKek() *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) ClearRetireAfter() *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) ClearRotatedAt() *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) Exec(ctx context.Context) error + func (_u *KEKVersionUpdateOne) ExecX(ctx context.Context) + func (_u *KEKVersionUpdateOne) Mutation() *KEKVersionMutation + func (_u *KEKVersionUpdateOne) Save(ctx context.Context) (*KEKVersion, error) + func (_u *KEKVersionUpdateOne) SaveX(ctx context.Context) *KEKVersion + func (_u *KEKVersionUpdateOne) Select(field string, fields ...string) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetActivatedAt(v time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetCreatedAt(v time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetKek(v *KEK) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetKekID(v envelope.ID) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableActivatedAt(v *time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableCreatedAt(v *time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableKekID(v *envelope.ID) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableProviderRef(v *string) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableRetireAfter(v *time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableRotatedAt(v *time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableState(v *uint8) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetNillableVersion(v *uint32) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetProviderRef(v string) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetRetireAfter(v time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetRotatedAt(v time.Time) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetState(v uint8) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) SetVersion(v uint32) *KEKVersionUpdateOne + func (_u *KEKVersionUpdateOne) Where(ps ...predicate.KEKVersion) *KEKVersionUpdateOne + func (c *KEKVersionUpdateOne) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *KEKVersionUpdateOne) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type KEKVersionUpsert struct + func (u *KEKVersionUpsert) AddState(v uint8) *KEKVersionUpsert + func (u *KEKVersionUpsert) AddVersion(v uint32) *KEKVersionUpsert + func (u *KEKVersionUpsert) ClearActivatedAt() *KEKVersionUpsert + func (u *KEKVersionUpsert) ClearRetireAfter() *KEKVersionUpsert + func (u *KEKVersionUpsert) ClearRotatedAt() *KEKVersionUpsert + func (u *KEKVersionUpsert) SetActivatedAt(v time.Time) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetCreatedAt(v time.Time) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetKekID(v envelope.ID) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetProviderRef(v string) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetRetireAfter(v time.Time) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetRotatedAt(v time.Time) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetState(v uint8) *KEKVersionUpsert + func (u *KEKVersionUpsert) SetVersion(v uint32) *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateActivatedAt() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateCreatedAt() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateKekID() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateProviderRef() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateRetireAfter() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateRotatedAt() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateState() *KEKVersionUpsert + func (u *KEKVersionUpsert) UpdateVersion() *KEKVersionUpsert + type KEKVersionUpsertBulk struct + func (u *KEKVersionUpsertBulk) AddState(v uint8) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) AddVersion(v uint32) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) ClearActivatedAt() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) ClearRetireAfter() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) ClearRotatedAt() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) DoNothing() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) Exec(ctx context.Context) error + func (u *KEKVersionUpsertBulk) ExecX(ctx context.Context) + func (u *KEKVersionUpsertBulk) Ignore() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetActivatedAt(v time.Time) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetCreatedAt(v time.Time) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetKekID(v envelope.ID) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetProviderRef(v string) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetRetireAfter(v time.Time) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetRotatedAt(v time.Time) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetState(v uint8) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) SetVersion(v uint32) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) Update(set func(*KEKVersionUpsert)) *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateActivatedAt() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateCreatedAt() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateKekID() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateNewValues() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateProviderRef() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateRetireAfter() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateRotatedAt() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateState() *KEKVersionUpsertBulk + func (u *KEKVersionUpsertBulk) UpdateVersion() *KEKVersionUpsertBulk + type KEKVersionUpsertOne struct + func (u *KEKVersionUpsertOne) AddState(v uint8) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) AddVersion(v uint32) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) ClearActivatedAt() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) ClearRetireAfter() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) ClearRotatedAt() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) DoNothing() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) Exec(ctx context.Context) error + func (u *KEKVersionUpsertOne) ExecX(ctx context.Context) + func (u *KEKVersionUpsertOne) ID(ctx context.Context) (id int, err error) + func (u *KEKVersionUpsertOne) IDX(ctx context.Context) int + func (u *KEKVersionUpsertOne) Ignore() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetActivatedAt(v time.Time) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetCreatedAt(v time.Time) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetKekID(v envelope.ID) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetProviderRef(v string) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetRetireAfter(v time.Time) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetRotatedAt(v time.Time) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetState(v uint8) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) SetVersion(v uint32) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) Update(set func(*KEKVersionUpsert)) *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateActivatedAt() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateCreatedAt() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateKekID() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateNewValues() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateProviderRef() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateRetireAfter() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateRotatedAt() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateState() *KEKVersionUpsertOne + func (u *KEKVersionUpsertOne) UpdateVersion() *KEKVersionUpsertOne + type KEKVersions []*KEKVersion + type KEKs []*KEK + type MutateFunc = ent.MutateFunc + type Mutation = ent.Mutation + type Mutator = ent.Mutator + 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 + type OrderFunc func(*sql.Selector) + type Policy = ent.Policy + 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 Sentinel struct + CreatedAt time.Time + Edges SentinelEdges + Envelope string + ID int + KekID envelope.ID + Version uint32 + func (_m *Sentinel) QueryKek() *KEKQuery + func (_m *Sentinel) String() string + func (_m *Sentinel) Unwrap() *Sentinel + func (_m *Sentinel) Update() *SentinelUpdateOne + func (_m *Sentinel) Value(name string) (ent.Value, error) + func (c *Sentinel) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *Sentinel) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelClient struct + func NewSentinelClient(c config) *SentinelClient + func (c *SentinelClient) Create() *SentinelCreate + func (c *SentinelClient) CreateBulk(builders ...*SentinelCreate) *SentinelCreateBulk + func (c *SentinelClient) Delete() *SentinelDelete + func (c *SentinelClient) DeleteOne(_m *Sentinel) *SentinelDeleteOne + func (c *SentinelClient) DeleteOneID(id int) *SentinelDeleteOne + func (c *SentinelClient) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelClient) Get(ctx context.Context, id int) (*Sentinel, error) + func (c *SentinelClient) GetX(ctx context.Context, id int) *Sentinel + func (c *SentinelClient) Hooks() []Hook + func (c *SentinelClient) Intercept(interceptors ...Interceptor) + func (c *SentinelClient) Interceptors() []Interceptor + func (c *SentinelClient) MapCreateBulk(slice any, setFunc func(*SentinelCreate, int)) *SentinelCreateBulk + func (c *SentinelClient) Query() *SentinelQuery + func (c *SentinelClient) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (c *SentinelClient) QueryKek(_m *Sentinel) *KEKQuery + func (c *SentinelClient) Update() *SentinelUpdate + func (c *SentinelClient) UpdateOne(_m *Sentinel) *SentinelUpdateOne + func (c *SentinelClient) UpdateOneID(id int) *SentinelUpdateOne + func (c *SentinelClient) Use(hooks ...Hook) + type SentinelCreate struct + func (_c *SentinelCreate) Exec(ctx context.Context) error + func (_c *SentinelCreate) ExecX(ctx context.Context) + func (_c *SentinelCreate) Mutation() *SentinelMutation + func (_c *SentinelCreate) OnConflict(opts ...sql.ConflictOption) *SentinelUpsertOne + func (_c *SentinelCreate) OnConflictColumns(columns ...string) *SentinelUpsertOne + func (_c *SentinelCreate) Save(ctx context.Context) (*Sentinel, error) + func (_c *SentinelCreate) SaveX(ctx context.Context) *Sentinel + func (_c *SentinelCreate) SetCreatedAt(v time.Time) *SentinelCreate + func (_c *SentinelCreate) SetEnvelope(v string) *SentinelCreate + func (_c *SentinelCreate) SetKek(v *KEK) *SentinelCreate + func (_c *SentinelCreate) SetKekID(v envelope.ID) *SentinelCreate + func (_c *SentinelCreate) SetVersion(v uint32) *SentinelCreate + func (c *SentinelCreate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelCreate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelCreateBulk struct + func (_c *SentinelCreateBulk) Exec(ctx context.Context) error + func (_c *SentinelCreateBulk) ExecX(ctx context.Context) + func (_c *SentinelCreateBulk) OnConflict(opts ...sql.ConflictOption) *SentinelUpsertBulk + func (_c *SentinelCreateBulk) OnConflictColumns(columns ...string) *SentinelUpsertBulk + func (_c *SentinelCreateBulk) Save(ctx context.Context) ([]*Sentinel, error) + func (_c *SentinelCreateBulk) SaveX(ctx context.Context) []*Sentinel + func (c *SentinelCreateBulk) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelCreateBulk) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelDelete struct + func (_d *SentinelDelete) Exec(ctx context.Context) (int, error) + func (_d *SentinelDelete) ExecX(ctx context.Context) int + func (_d *SentinelDelete) Where(ps ...predicate.Sentinel) *SentinelDelete + func (c *SentinelDelete) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelDelete) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelDeleteOne struct + func (_d *SentinelDeleteOne) Exec(ctx context.Context) error + func (_d *SentinelDeleteOne) ExecX(ctx context.Context) + func (_d *SentinelDeleteOne) Where(ps ...predicate.Sentinel) *SentinelDeleteOne + type SentinelEdges struct + Kek *KEK + func (e SentinelEdges) KekOrErr() (*KEK, error) + type SentinelGroupBy struct + func (_g *SentinelGroupBy) Aggregate(fns ...AggregateFunc) *SentinelGroupBy + func (_g *SentinelGroupBy) Scan(ctx context.Context, v any) error + func (s *SentinelGroupBy) Bool(ctx context.Context) (_ bool, err error) + func (s *SentinelGroupBy) BoolX(ctx context.Context) bool + func (s *SentinelGroupBy) Bools(ctx context.Context) ([]bool, error) + func (s *SentinelGroupBy) BoolsX(ctx context.Context) []bool + func (s *SentinelGroupBy) Float64(ctx context.Context) (_ float64, err error) + func (s *SentinelGroupBy) Float64X(ctx context.Context) float64 + func (s *SentinelGroupBy) Float64s(ctx context.Context) ([]float64, error) + func (s *SentinelGroupBy) Float64sX(ctx context.Context) []float64 + func (s *SentinelGroupBy) Int(ctx context.Context) (_ int, err error) + func (s *SentinelGroupBy) IntX(ctx context.Context) int + func (s *SentinelGroupBy) Ints(ctx context.Context) ([]int, error) + func (s *SentinelGroupBy) IntsX(ctx context.Context) []int + func (s *SentinelGroupBy) ScanX(ctx context.Context, v any) + func (s *SentinelGroupBy) String(ctx context.Context) (_ string, err error) + func (s *SentinelGroupBy) StringX(ctx context.Context) string + func (s *SentinelGroupBy) Strings(ctx context.Context) ([]string, error) + func (s *SentinelGroupBy) StringsX(ctx context.Context) []string + type SentinelMutation struct + func (c *SentinelMutation) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelMutation) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (m *SentinelMutation) AddField(name string, value ent.Value) error + func (m *SentinelMutation) AddVersion(u int32) + func (m *SentinelMutation) AddedEdges() []string + func (m *SentinelMutation) AddedField(name string) (ent.Value, bool) + func (m *SentinelMutation) AddedFields() []string + func (m *SentinelMutation) AddedIDs(name string) []ent.Value + func (m *SentinelMutation) AddedVersion() (r int32, exists bool) + func (m *SentinelMutation) ClearEdge(name string) error + func (m *SentinelMutation) ClearField(name string) error + func (m *SentinelMutation) ClearKek() + func (m *SentinelMutation) ClearedEdges() []string + func (m *SentinelMutation) ClearedFields() []string + func (m *SentinelMutation) CreatedAt() (r time.Time, exists bool) + func (m *SentinelMutation) EdgeCleared(name string) bool + func (m *SentinelMutation) Envelope() (r string, exists bool) + func (m *SentinelMutation) Field(name string) (ent.Value, bool) + func (m *SentinelMutation) FieldCleared(name string) bool + func (m *SentinelMutation) Fields() []string + func (m *SentinelMutation) ID() (id int, exists bool) + func (m *SentinelMutation) IDs(ctx context.Context) ([]int, error) + func (m *SentinelMutation) KekCleared() bool + func (m *SentinelMutation) KekID() (r envelope.ID, exists bool) + func (m *SentinelMutation) KekIDs() (ids []envelope.ID) + func (m *SentinelMutation) OldCreatedAt(ctx context.Context) (v time.Time, err error) + func (m *SentinelMutation) OldEnvelope(ctx context.Context) (v string, err error) + func (m *SentinelMutation) OldField(ctx context.Context, name string) (ent.Value, error) + func (m *SentinelMutation) OldKekID(ctx context.Context) (v envelope.ID, err error) + func (m *SentinelMutation) OldVersion(ctx context.Context) (v uint32, err error) + func (m *SentinelMutation) Op() Op + func (m *SentinelMutation) RemovedEdges() []string + func (m *SentinelMutation) RemovedIDs(name string) []ent.Value + func (m *SentinelMutation) ResetCreatedAt() + func (m *SentinelMutation) ResetEdge(name string) error + func (m *SentinelMutation) ResetEnvelope() + func (m *SentinelMutation) ResetField(name string) error + func (m *SentinelMutation) ResetKek() + func (m *SentinelMutation) ResetKekID() + func (m *SentinelMutation) ResetVersion() + func (m *SentinelMutation) SetCreatedAt(t time.Time) + func (m *SentinelMutation) SetEnvelope(s string) + func (m *SentinelMutation) SetField(name string, value ent.Value) error + func (m *SentinelMutation) SetKekID(e envelope.ID) + func (m *SentinelMutation) SetOp(op Op) + func (m *SentinelMutation) SetVersion(u uint32) + func (m *SentinelMutation) Type() string + func (m *SentinelMutation) Version() (r uint32, exists bool) + func (m *SentinelMutation) Where(ps ...predicate.Sentinel) + func (m *SentinelMutation) WhereP(ps ...func(*sql.Selector)) + func (m SentinelMutation) Client() *Client + func (m SentinelMutation) Tx() (*Tx, error) + type SentinelQuery struct + func (_q *SentinelQuery) Aggregate(fns ...AggregateFunc) *SentinelSelect + func (_q *SentinelQuery) All(ctx context.Context) ([]*Sentinel, error) + func (_q *SentinelQuery) AllX(ctx context.Context) []*Sentinel + func (_q *SentinelQuery) Clone() *SentinelQuery + func (_q *SentinelQuery) Count(ctx context.Context) (int, error) + func (_q *SentinelQuery) CountX(ctx context.Context) int + func (_q *SentinelQuery) Exist(ctx context.Context) (bool, error) + func (_q *SentinelQuery) ExistX(ctx context.Context) bool + func (_q *SentinelQuery) First(ctx context.Context) (*Sentinel, error) + func (_q *SentinelQuery) FirstID(ctx context.Context) (id int, err error) + func (_q *SentinelQuery) FirstIDX(ctx context.Context) int + func (_q *SentinelQuery) FirstX(ctx context.Context) *Sentinel + func (_q *SentinelQuery) ForShare(opts ...sql.LockOption) *SentinelQuery + func (_q *SentinelQuery) ForUpdate(opts ...sql.LockOption) *SentinelQuery + func (_q *SentinelQuery) GroupBy(field string, fields ...string) *SentinelGroupBy + func (_q *SentinelQuery) IDs(ctx context.Context) (ids []int, err error) + func (_q *SentinelQuery) IDsX(ctx context.Context) []int + func (_q *SentinelQuery) Limit(limit int) *SentinelQuery + func (_q *SentinelQuery) Offset(offset int) *SentinelQuery + func (_q *SentinelQuery) Only(ctx context.Context) (*Sentinel, error) + func (_q *SentinelQuery) OnlyID(ctx context.Context) (id int, err error) + func (_q *SentinelQuery) OnlyIDX(ctx context.Context) int + func (_q *SentinelQuery) OnlyX(ctx context.Context) *Sentinel + func (_q *SentinelQuery) Order(o ...sentinel.OrderOption) *SentinelQuery + func (_q *SentinelQuery) QueryKek() *KEKQuery + func (_q *SentinelQuery) Select(fields ...string) *SentinelSelect + func (_q *SentinelQuery) Unique(unique bool) *SentinelQuery + func (_q *SentinelQuery) Where(ps ...predicate.Sentinel) *SentinelQuery + func (_q *SentinelQuery) WithKek(opts ...func(*KEKQuery)) *SentinelQuery + func (c *SentinelQuery) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelQuery) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelSelect struct + func (_s *SentinelSelect) Aggregate(fns ...AggregateFunc) *SentinelSelect + func (_s *SentinelSelect) Scan(ctx context.Context, v any) error + func (c SentinelSelect) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c SentinelSelect) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (s *SentinelSelect) Bool(ctx context.Context) (_ bool, err error) + func (s *SentinelSelect) BoolX(ctx context.Context) bool + func (s *SentinelSelect) Bools(ctx context.Context) ([]bool, error) + func (s *SentinelSelect) BoolsX(ctx context.Context) []bool + func (s *SentinelSelect) Float64(ctx context.Context) (_ float64, err error) + func (s *SentinelSelect) Float64X(ctx context.Context) float64 + func (s *SentinelSelect) Float64s(ctx context.Context) ([]float64, error) + func (s *SentinelSelect) Float64sX(ctx context.Context) []float64 + func (s *SentinelSelect) Int(ctx context.Context) (_ int, err error) + func (s *SentinelSelect) IntX(ctx context.Context) int + func (s *SentinelSelect) Ints(ctx context.Context) ([]int, error) + func (s *SentinelSelect) IntsX(ctx context.Context) []int + func (s *SentinelSelect) ScanX(ctx context.Context, v any) + func (s *SentinelSelect) String(ctx context.Context) (_ string, err error) + func (s *SentinelSelect) StringX(ctx context.Context) string + func (s *SentinelSelect) Strings(ctx context.Context) ([]string, error) + func (s *SentinelSelect) StringsX(ctx context.Context) []string + type SentinelUpdate struct + func (_u *SentinelUpdate) AddVersion(v int32) *SentinelUpdate + func (_u *SentinelUpdate) ClearKek() *SentinelUpdate + func (_u *SentinelUpdate) Exec(ctx context.Context) error + func (_u *SentinelUpdate) ExecX(ctx context.Context) + func (_u *SentinelUpdate) Mutation() *SentinelMutation + func (_u *SentinelUpdate) Save(ctx context.Context) (int, error) + func (_u *SentinelUpdate) SaveX(ctx context.Context) int + func (_u *SentinelUpdate) SetCreatedAt(v time.Time) *SentinelUpdate + func (_u *SentinelUpdate) SetEnvelope(v string) *SentinelUpdate + func (_u *SentinelUpdate) SetKek(v *KEK) *SentinelUpdate + func (_u *SentinelUpdate) SetKekID(v envelope.ID) *SentinelUpdate + func (_u *SentinelUpdate) SetNillableCreatedAt(v *time.Time) *SentinelUpdate + func (_u *SentinelUpdate) SetNillableEnvelope(v *string) *SentinelUpdate + func (_u *SentinelUpdate) SetNillableKekID(v *envelope.ID) *SentinelUpdate + func (_u *SentinelUpdate) SetNillableVersion(v *uint32) *SentinelUpdate + func (_u *SentinelUpdate) SetVersion(v uint32) *SentinelUpdate + func (_u *SentinelUpdate) Where(ps ...predicate.Sentinel) *SentinelUpdate + func (c *SentinelUpdate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelUpdate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelUpdateOne struct + func (_u *SentinelUpdateOne) AddVersion(v int32) *SentinelUpdateOne + func (_u *SentinelUpdateOne) ClearKek() *SentinelUpdateOne + func (_u *SentinelUpdateOne) Exec(ctx context.Context) error + func (_u *SentinelUpdateOne) ExecX(ctx context.Context) + func (_u *SentinelUpdateOne) Mutation() *SentinelMutation + func (_u *SentinelUpdateOne) Save(ctx context.Context) (*Sentinel, error) + func (_u *SentinelUpdateOne) SaveX(ctx context.Context) *Sentinel + func (_u *SentinelUpdateOne) Select(field string, fields ...string) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetCreatedAt(v time.Time) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetEnvelope(v string) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetKek(v *KEK) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetKekID(v envelope.ID) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetNillableCreatedAt(v *time.Time) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetNillableEnvelope(v *string) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetNillableKekID(v *envelope.ID) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetNillableVersion(v *uint32) *SentinelUpdateOne + func (_u *SentinelUpdateOne) SetVersion(v uint32) *SentinelUpdateOne + func (_u *SentinelUpdateOne) Where(ps ...predicate.Sentinel) *SentinelUpdateOne + func (c *SentinelUpdateOne) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *SentinelUpdateOne) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type SentinelUpsert struct + func (u *SentinelUpsert) AddVersion(v uint32) *SentinelUpsert + func (u *SentinelUpsert) SetCreatedAt(v time.Time) *SentinelUpsert + func (u *SentinelUpsert) SetEnvelope(v string) *SentinelUpsert + func (u *SentinelUpsert) SetKekID(v envelope.ID) *SentinelUpsert + func (u *SentinelUpsert) SetVersion(v uint32) *SentinelUpsert + func (u *SentinelUpsert) UpdateCreatedAt() *SentinelUpsert + func (u *SentinelUpsert) UpdateEnvelope() *SentinelUpsert + func (u *SentinelUpsert) UpdateKekID() *SentinelUpsert + func (u *SentinelUpsert) UpdateVersion() *SentinelUpsert + type SentinelUpsertBulk struct + func (u *SentinelUpsertBulk) AddVersion(v uint32) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) DoNothing() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) Exec(ctx context.Context) error + func (u *SentinelUpsertBulk) ExecX(ctx context.Context) + func (u *SentinelUpsertBulk) Ignore() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) SetCreatedAt(v time.Time) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) SetEnvelope(v string) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) SetKekID(v envelope.ID) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) SetVersion(v uint32) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) Update(set func(*SentinelUpsert)) *SentinelUpsertBulk + func (u *SentinelUpsertBulk) UpdateCreatedAt() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) UpdateEnvelope() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) UpdateKekID() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) UpdateNewValues() *SentinelUpsertBulk + func (u *SentinelUpsertBulk) UpdateVersion() *SentinelUpsertBulk + type SentinelUpsertOne struct + func (u *SentinelUpsertOne) AddVersion(v uint32) *SentinelUpsertOne + func (u *SentinelUpsertOne) DoNothing() *SentinelUpsertOne + func (u *SentinelUpsertOne) Exec(ctx context.Context) error + func (u *SentinelUpsertOne) ExecX(ctx context.Context) + func (u *SentinelUpsertOne) ID(ctx context.Context) (id int, err error) + func (u *SentinelUpsertOne) IDX(ctx context.Context) int + func (u *SentinelUpsertOne) Ignore() *SentinelUpsertOne + func (u *SentinelUpsertOne) SetCreatedAt(v time.Time) *SentinelUpsertOne + func (u *SentinelUpsertOne) SetEnvelope(v string) *SentinelUpsertOne + func (u *SentinelUpsertOne) SetKekID(v envelope.ID) *SentinelUpsertOne + func (u *SentinelUpsertOne) SetVersion(v uint32) *SentinelUpsertOne + func (u *SentinelUpsertOne) Update(set func(*SentinelUpsert)) *SentinelUpsertOne + func (u *SentinelUpsertOne) UpdateCreatedAt() *SentinelUpsertOne + func (u *SentinelUpsertOne) UpdateEnvelope() *SentinelUpsertOne + func (u *SentinelUpsertOne) UpdateKekID() *SentinelUpsertOne + func (u *SentinelUpsertOne) UpdateNewValues() *SentinelUpsertOne + func (u *SentinelUpsertOne) UpdateVersion() *SentinelUpsertOne + type Sentinels []*Sentinel + type Shred struct + CompletedAt *time.Time + Deks int + ID int + Purpose string + RequestedAt time.Time + Subject string + Versions []keyforge.KEKVersionRef + func (_m *Shred) String() string + func (_m *Shred) Unwrap() *Shred + func (_m *Shred) Update() *ShredUpdateOne + func (_m *Shred) Value(name string) (ent.Value, error) + func (c *Shred) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *Shred) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredClient struct + func NewShredClient(c config) *ShredClient + func (c *ShredClient) Create() *ShredCreate + func (c *ShredClient) CreateBulk(builders ...*ShredCreate) *ShredCreateBulk + func (c *ShredClient) Delete() *ShredDelete + func (c *ShredClient) DeleteOne(_m *Shred) *ShredDeleteOne + func (c *ShredClient) DeleteOneID(id int) *ShredDeleteOne + func (c *ShredClient) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredClient) Get(ctx context.Context, id int) (*Shred, error) + func (c *ShredClient) GetX(ctx context.Context, id int) *Shred + func (c *ShredClient) Hooks() []Hook + func (c *ShredClient) Intercept(interceptors ...Interceptor) + func (c *ShredClient) Interceptors() []Interceptor + func (c *ShredClient) MapCreateBulk(slice any, setFunc func(*ShredCreate, int)) *ShredCreateBulk + func (c *ShredClient) Query() *ShredQuery + func (c *ShredClient) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (c *ShredClient) Update() *ShredUpdate + func (c *ShredClient) UpdateOne(_m *Shred) *ShredUpdateOne + func (c *ShredClient) UpdateOneID(id int) *ShredUpdateOne + func (c *ShredClient) Use(hooks ...Hook) + type ShredCreate struct + func (_c *ShredCreate) Exec(ctx context.Context) error + func (_c *ShredCreate) ExecX(ctx context.Context) + func (_c *ShredCreate) Mutation() *ShredMutation + func (_c *ShredCreate) OnConflict(opts ...sql.ConflictOption) *ShredUpsertOne + func (_c *ShredCreate) OnConflictColumns(columns ...string) *ShredUpsertOne + func (_c *ShredCreate) Save(ctx context.Context) (*Shred, error) + func (_c *ShredCreate) SaveX(ctx context.Context) *Shred + func (_c *ShredCreate) SetCompletedAt(v time.Time) *ShredCreate + func (_c *ShredCreate) SetDeks(v int) *ShredCreate + func (_c *ShredCreate) SetNillableCompletedAt(v *time.Time) *ShredCreate + func (_c *ShredCreate) SetNillableDeks(v *int) *ShredCreate + func (_c *ShredCreate) SetPurpose(v string) *ShredCreate + func (_c *ShredCreate) SetRequestedAt(v time.Time) *ShredCreate + func (_c *ShredCreate) SetSubject(v string) *ShredCreate + func (_c *ShredCreate) SetVersions(v []keyforge.KEKVersionRef) *ShredCreate + func (c *ShredCreate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredCreate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredCreateBulk struct + func (_c *ShredCreateBulk) Exec(ctx context.Context) error + func (_c *ShredCreateBulk) ExecX(ctx context.Context) + func (_c *ShredCreateBulk) OnConflict(opts ...sql.ConflictOption) *ShredUpsertBulk + func (_c *ShredCreateBulk) OnConflictColumns(columns ...string) *ShredUpsertBulk + func (_c *ShredCreateBulk) Save(ctx context.Context) ([]*Shred, error) + func (_c *ShredCreateBulk) SaveX(ctx context.Context) []*Shred + func (c *ShredCreateBulk) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredCreateBulk) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredDelete struct + func (_d *ShredDelete) Exec(ctx context.Context) (int, error) + func (_d *ShredDelete) ExecX(ctx context.Context) int + func (_d *ShredDelete) Where(ps ...predicate.Shred) *ShredDelete + func (c *ShredDelete) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredDelete) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredDeleteOne struct + func (_d *ShredDeleteOne) Exec(ctx context.Context) error + func (_d *ShredDeleteOne) ExecX(ctx context.Context) + func (_d *ShredDeleteOne) Where(ps ...predicate.Shred) *ShredDeleteOne + type ShredGroupBy struct + func (_g *ShredGroupBy) Aggregate(fns ...AggregateFunc) *ShredGroupBy + func (_g *ShredGroupBy) Scan(ctx context.Context, v any) error + func (s *ShredGroupBy) Bool(ctx context.Context) (_ bool, err error) + func (s *ShredGroupBy) BoolX(ctx context.Context) bool + func (s *ShredGroupBy) Bools(ctx context.Context) ([]bool, error) + func (s *ShredGroupBy) BoolsX(ctx context.Context) []bool + func (s *ShredGroupBy) Float64(ctx context.Context) (_ float64, err error) + func (s *ShredGroupBy) Float64X(ctx context.Context) float64 + func (s *ShredGroupBy) Float64s(ctx context.Context) ([]float64, error) + func (s *ShredGroupBy) Float64sX(ctx context.Context) []float64 + func (s *ShredGroupBy) Int(ctx context.Context) (_ int, err error) + func (s *ShredGroupBy) IntX(ctx context.Context) int + func (s *ShredGroupBy) Ints(ctx context.Context) ([]int, error) + func (s *ShredGroupBy) IntsX(ctx context.Context) []int + func (s *ShredGroupBy) ScanX(ctx context.Context, v any) + func (s *ShredGroupBy) String(ctx context.Context) (_ string, err error) + func (s *ShredGroupBy) StringX(ctx context.Context) string + func (s *ShredGroupBy) Strings(ctx context.Context) ([]string, error) + func (s *ShredGroupBy) StringsX(ctx context.Context) []string + type ShredMutation struct + func (c *ShredMutation) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredMutation) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (m *ShredMutation) AddDeks(i int) + func (m *ShredMutation) AddField(name string, value ent.Value) error + func (m *ShredMutation) AddedDeks() (r int, exists bool) + func (m *ShredMutation) AddedEdges() []string + func (m *ShredMutation) AddedField(name string) (ent.Value, bool) + func (m *ShredMutation) AddedFields() []string + func (m *ShredMutation) AddedIDs(name string) []ent.Value + func (m *ShredMutation) AppendVersions(kvr []keyforge.KEKVersionRef) + func (m *ShredMutation) AppendedVersions() ([]keyforge.KEKVersionRef, bool) + func (m *ShredMutation) ClearCompletedAt() + func (m *ShredMutation) ClearEdge(name string) error + func (m *ShredMutation) ClearField(name string) error + func (m *ShredMutation) ClearedEdges() []string + func (m *ShredMutation) ClearedFields() []string + func (m *ShredMutation) CompletedAt() (r time.Time, exists bool) + func (m *ShredMutation) CompletedAtCleared() bool + func (m *ShredMutation) Deks() (r int, exists bool) + func (m *ShredMutation) EdgeCleared(name string) bool + func (m *ShredMutation) Field(name string) (ent.Value, bool) + func (m *ShredMutation) FieldCleared(name string) bool + func (m *ShredMutation) Fields() []string + func (m *ShredMutation) ID() (id int, exists bool) + func (m *ShredMutation) IDs(ctx context.Context) ([]int, error) + func (m *ShredMutation) OldCompletedAt(ctx context.Context) (v *time.Time, err error) + func (m *ShredMutation) OldDeks(ctx context.Context) (v int, err error) + func (m *ShredMutation) OldField(ctx context.Context, name string) (ent.Value, error) + func (m *ShredMutation) OldPurpose(ctx context.Context) (v string, err error) + func (m *ShredMutation) OldRequestedAt(ctx context.Context) (v time.Time, err error) + func (m *ShredMutation) OldSubject(ctx context.Context) (v string, err error) + func (m *ShredMutation) OldVersions(ctx context.Context) (v []keyforge.KEKVersionRef, err error) + func (m *ShredMutation) Op() Op + func (m *ShredMutation) Purpose() (r string, exists bool) + func (m *ShredMutation) RemovedEdges() []string + func (m *ShredMutation) RemovedIDs(name string) []ent.Value + func (m *ShredMutation) RequestedAt() (r time.Time, exists bool) + func (m *ShredMutation) ResetCompletedAt() + func (m *ShredMutation) ResetDeks() + func (m *ShredMutation) ResetEdge(name string) error + func (m *ShredMutation) ResetField(name string) error + func (m *ShredMutation) ResetPurpose() + func (m *ShredMutation) ResetRequestedAt() + func (m *ShredMutation) ResetSubject() + func (m *ShredMutation) ResetVersions() + func (m *ShredMutation) SetCompletedAt(t time.Time) + func (m *ShredMutation) SetDeks(i int) + func (m *ShredMutation) SetField(name string, value ent.Value) error + func (m *ShredMutation) SetOp(op Op) + func (m *ShredMutation) SetPurpose(s string) + func (m *ShredMutation) SetRequestedAt(t time.Time) + func (m *ShredMutation) SetSubject(s string) + func (m *ShredMutation) SetVersions(kvr []keyforge.KEKVersionRef) + func (m *ShredMutation) Subject() (r string, exists bool) + func (m *ShredMutation) Type() string + func (m *ShredMutation) Versions() (r []keyforge.KEKVersionRef, exists bool) + func (m *ShredMutation) Where(ps ...predicate.Shred) + func (m *ShredMutation) WhereP(ps ...func(*sql.Selector)) + func (m ShredMutation) Client() *Client + func (m ShredMutation) Tx() (*Tx, error) + type ShredQuery struct + func (_q *ShredQuery) Aggregate(fns ...AggregateFunc) *ShredSelect + func (_q *ShredQuery) All(ctx context.Context) ([]*Shred, error) + func (_q *ShredQuery) AllX(ctx context.Context) []*Shred + func (_q *ShredQuery) Clone() *ShredQuery + func (_q *ShredQuery) Count(ctx context.Context) (int, error) + func (_q *ShredQuery) CountX(ctx context.Context) int + func (_q *ShredQuery) Exist(ctx context.Context) (bool, error) + func (_q *ShredQuery) ExistX(ctx context.Context) bool + func (_q *ShredQuery) First(ctx context.Context) (*Shred, error) + func (_q *ShredQuery) FirstID(ctx context.Context) (id int, err error) + func (_q *ShredQuery) FirstIDX(ctx context.Context) int + func (_q *ShredQuery) FirstX(ctx context.Context) *Shred + func (_q *ShredQuery) ForShare(opts ...sql.LockOption) *ShredQuery + func (_q *ShredQuery) ForUpdate(opts ...sql.LockOption) *ShredQuery + func (_q *ShredQuery) GroupBy(field string, fields ...string) *ShredGroupBy + func (_q *ShredQuery) IDs(ctx context.Context) (ids []int, err error) + func (_q *ShredQuery) IDsX(ctx context.Context) []int + func (_q *ShredQuery) Limit(limit int) *ShredQuery + func (_q *ShredQuery) Offset(offset int) *ShredQuery + func (_q *ShredQuery) Only(ctx context.Context) (*Shred, error) + func (_q *ShredQuery) OnlyID(ctx context.Context) (id int, err error) + func (_q *ShredQuery) OnlyIDX(ctx context.Context) int + func (_q *ShredQuery) OnlyX(ctx context.Context) *Shred + func (_q *ShredQuery) Order(o ...shred.OrderOption) *ShredQuery + func (_q *ShredQuery) Select(fields ...string) *ShredSelect + func (_q *ShredQuery) Unique(unique bool) *ShredQuery + func (_q *ShredQuery) Where(ps ...predicate.Shred) *ShredQuery + func (c *ShredQuery) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredQuery) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredSelect struct + func (_s *ShredSelect) Aggregate(fns ...AggregateFunc) *ShredSelect + func (_s *ShredSelect) Scan(ctx context.Context, v any) error + func (c ShredSelect) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c ShredSelect) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (s *ShredSelect) Bool(ctx context.Context) (_ bool, err error) + func (s *ShredSelect) BoolX(ctx context.Context) bool + func (s *ShredSelect) Bools(ctx context.Context) ([]bool, error) + func (s *ShredSelect) BoolsX(ctx context.Context) []bool + func (s *ShredSelect) Float64(ctx context.Context) (_ float64, err error) + func (s *ShredSelect) Float64X(ctx context.Context) float64 + func (s *ShredSelect) Float64s(ctx context.Context) ([]float64, error) + func (s *ShredSelect) Float64sX(ctx context.Context) []float64 + func (s *ShredSelect) Int(ctx context.Context) (_ int, err error) + func (s *ShredSelect) IntX(ctx context.Context) int + func (s *ShredSelect) Ints(ctx context.Context) ([]int, error) + func (s *ShredSelect) IntsX(ctx context.Context) []int + func (s *ShredSelect) ScanX(ctx context.Context, v any) + func (s *ShredSelect) String(ctx context.Context) (_ string, err error) + func (s *ShredSelect) StringX(ctx context.Context) string + func (s *ShredSelect) Strings(ctx context.Context) ([]string, error) + func (s *ShredSelect) StringsX(ctx context.Context) []string + type ShredUpdate struct + func (_u *ShredUpdate) AddDeks(v int) *ShredUpdate + func (_u *ShredUpdate) AppendVersions(v []keyforge.KEKVersionRef) *ShredUpdate + func (_u *ShredUpdate) ClearCompletedAt() *ShredUpdate + func (_u *ShredUpdate) Exec(ctx context.Context) error + func (_u *ShredUpdate) ExecX(ctx context.Context) + func (_u *ShredUpdate) Mutation() *ShredMutation + func (_u *ShredUpdate) Save(ctx context.Context) (int, error) + func (_u *ShredUpdate) SaveX(ctx context.Context) int + func (_u *ShredUpdate) SetCompletedAt(v time.Time) *ShredUpdate + func (_u *ShredUpdate) SetDeks(v int) *ShredUpdate + func (_u *ShredUpdate) SetNillableCompletedAt(v *time.Time) *ShredUpdate + func (_u *ShredUpdate) SetNillableDeks(v *int) *ShredUpdate + func (_u *ShredUpdate) SetNillablePurpose(v *string) *ShredUpdate + func (_u *ShredUpdate) SetNillableRequestedAt(v *time.Time) *ShredUpdate + func (_u *ShredUpdate) SetNillableSubject(v *string) *ShredUpdate + func (_u *ShredUpdate) SetPurpose(v string) *ShredUpdate + func (_u *ShredUpdate) SetRequestedAt(v time.Time) *ShredUpdate + func (_u *ShredUpdate) SetSubject(v string) *ShredUpdate + func (_u *ShredUpdate) SetVersions(v []keyforge.KEKVersionRef) *ShredUpdate + func (_u *ShredUpdate) Where(ps ...predicate.Shred) *ShredUpdate + func (c *ShredUpdate) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredUpdate) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredUpdateOne struct + func (_u *ShredUpdateOne) AddDeks(v int) *ShredUpdateOne + func (_u *ShredUpdateOne) AppendVersions(v []keyforge.KEKVersionRef) *ShredUpdateOne + func (_u *ShredUpdateOne) ClearCompletedAt() *ShredUpdateOne + func (_u *ShredUpdateOne) Exec(ctx context.Context) error + func (_u *ShredUpdateOne) ExecX(ctx context.Context) + func (_u *ShredUpdateOne) Mutation() *ShredMutation + func (_u *ShredUpdateOne) Save(ctx context.Context) (*Shred, error) + func (_u *ShredUpdateOne) SaveX(ctx context.Context) *Shred + func (_u *ShredUpdateOne) Select(field string, fields ...string) *ShredUpdateOne + func (_u *ShredUpdateOne) SetCompletedAt(v time.Time) *ShredUpdateOne + func (_u *ShredUpdateOne) SetDeks(v int) *ShredUpdateOne + func (_u *ShredUpdateOne) SetNillableCompletedAt(v *time.Time) *ShredUpdateOne + func (_u *ShredUpdateOne) SetNillableDeks(v *int) *ShredUpdateOne + func (_u *ShredUpdateOne) SetNillablePurpose(v *string) *ShredUpdateOne + func (_u *ShredUpdateOne) SetNillableRequestedAt(v *time.Time) *ShredUpdateOne + func (_u *ShredUpdateOne) SetNillableSubject(v *string) *ShredUpdateOne + func (_u *ShredUpdateOne) SetPurpose(v string) *ShredUpdateOne + func (_u *ShredUpdateOne) SetRequestedAt(v time.Time) *ShredUpdateOne + func (_u *ShredUpdateOne) SetSubject(v string) *ShredUpdateOne + func (_u *ShredUpdateOne) SetVersions(v []keyforge.KEKVersionRef) *ShredUpdateOne + func (_u *ShredUpdateOne) Where(ps ...predicate.Shred) *ShredUpdateOne + func (c *ShredUpdateOne) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *ShredUpdateOne) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + type ShredUpsert struct + func (u *ShredUpsert) AddDeks(v int) *ShredUpsert + func (u *ShredUpsert) ClearCompletedAt() *ShredUpsert + func (u *ShredUpsert) SetCompletedAt(v time.Time) *ShredUpsert + func (u *ShredUpsert) SetDeks(v int) *ShredUpsert + func (u *ShredUpsert) SetPurpose(v string) *ShredUpsert + func (u *ShredUpsert) SetRequestedAt(v time.Time) *ShredUpsert + func (u *ShredUpsert) SetSubject(v string) *ShredUpsert + func (u *ShredUpsert) SetVersions(v []keyforge.KEKVersionRef) *ShredUpsert + func (u *ShredUpsert) UpdateCompletedAt() *ShredUpsert + func (u *ShredUpsert) UpdateDeks() *ShredUpsert + func (u *ShredUpsert) UpdatePurpose() *ShredUpsert + func (u *ShredUpsert) UpdateRequestedAt() *ShredUpsert + func (u *ShredUpsert) UpdateSubject() *ShredUpsert + func (u *ShredUpsert) UpdateVersions() *ShredUpsert + type ShredUpsertBulk struct + func (u *ShredUpsertBulk) AddDeks(v int) *ShredUpsertBulk + func (u *ShredUpsertBulk) ClearCompletedAt() *ShredUpsertBulk + func (u *ShredUpsertBulk) DoNothing() *ShredUpsertBulk + func (u *ShredUpsertBulk) Exec(ctx context.Context) error + func (u *ShredUpsertBulk) ExecX(ctx context.Context) + func (u *ShredUpsertBulk) Ignore() *ShredUpsertBulk + func (u *ShredUpsertBulk) SetCompletedAt(v time.Time) *ShredUpsertBulk + func (u *ShredUpsertBulk) SetDeks(v int) *ShredUpsertBulk + func (u *ShredUpsertBulk) SetPurpose(v string) *ShredUpsertBulk + func (u *ShredUpsertBulk) SetRequestedAt(v time.Time) *ShredUpsertBulk + func (u *ShredUpsertBulk) SetSubject(v string) *ShredUpsertBulk + func (u *ShredUpsertBulk) SetVersions(v []keyforge.KEKVersionRef) *ShredUpsertBulk + func (u *ShredUpsertBulk) Update(set func(*ShredUpsert)) *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateCompletedAt() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateDeks() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateNewValues() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdatePurpose() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateRequestedAt() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateSubject() *ShredUpsertBulk + func (u *ShredUpsertBulk) UpdateVersions() *ShredUpsertBulk + type ShredUpsertOne struct + func (u *ShredUpsertOne) AddDeks(v int) *ShredUpsertOne + func (u *ShredUpsertOne) ClearCompletedAt() *ShredUpsertOne + func (u *ShredUpsertOne) DoNothing() *ShredUpsertOne + func (u *ShredUpsertOne) Exec(ctx context.Context) error + func (u *ShredUpsertOne) ExecX(ctx context.Context) + func (u *ShredUpsertOne) ID(ctx context.Context) (id int, err error) + func (u *ShredUpsertOne) IDX(ctx context.Context) int + func (u *ShredUpsertOne) Ignore() *ShredUpsertOne + func (u *ShredUpsertOne) SetCompletedAt(v time.Time) *ShredUpsertOne + func (u *ShredUpsertOne) SetDeks(v int) *ShredUpsertOne + func (u *ShredUpsertOne) SetPurpose(v string) *ShredUpsertOne + func (u *ShredUpsertOne) SetRequestedAt(v time.Time) *ShredUpsertOne + func (u *ShredUpsertOne) SetSubject(v string) *ShredUpsertOne + func (u *ShredUpsertOne) SetVersions(v []keyforge.KEKVersionRef) *ShredUpsertOne + func (u *ShredUpsertOne) Update(set func(*ShredUpsert)) *ShredUpsertOne + func (u *ShredUpsertOne) UpdateCompletedAt() *ShredUpsertOne + func (u *ShredUpsertOne) UpdateDeks() *ShredUpsertOne + func (u *ShredUpsertOne) UpdateNewValues() *ShredUpsertOne + func (u *ShredUpsertOne) UpdatePurpose() *ShredUpsertOne + func (u *ShredUpsertOne) UpdateRequestedAt() *ShredUpsertOne + func (u *ShredUpsertOne) UpdateSubject() *ShredUpsertOne + func (u *ShredUpsertOne) UpdateVersions() *ShredUpsertOne + type Shreds []*Shred + type TraverseFunc = ent.TraverseFunc + type Traverser = ent.Traverser + type Tx struct + DataKey *DataKeyClient + KEK *KEKClient + KEKVersion *KEKVersionClient + Sentinel *SentinelClient + Shred *ShredClient + func TxFromContext(ctx context.Context) *Tx + func (c *Tx) ExecContext(ctx context.Context, query string, args ...any) (stdsql.Result, error) + func (c *Tx) QueryContext(ctx context.Context, query string, args ...any) (*stdsql.Rows, error) + func (tx *Tx) Client() *Client + func (tx *Tx) Commit() error + func (tx *Tx) OnCommit(f CommitHook) + func (tx *Tx) OnRollback(f RollbackHook) + func (tx *Tx) Rollback() error + type ValidationError struct + Name string + func (e *ValidationError) Error() string + func (e *ValidationError) Unwrap() error + type Value = ent.Value
Go to main page