add seven

ent/client.go

@@ -13,6 +13,7 @@ import (
 	"api/ent/card"
 	"api/ent/group"
 	"api/ent/ma"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 
@@ -33,6 +34,8 @@ type Client struct {
 	Group *GroupClient
 	// Ma is the client for interacting with the Ma builders.
 	Ma *MaClient
+	// Sev is the client for interacting with the Sev builders.
+	Sev *SevClient
 	// Ue is the client for interacting with the Ue builders.
 	Ue *UeClient
 	// User is the client for interacting with the User builders.
@@ -53,6 +56,7 @@ func (c *Client) init() {
 	c.Card = NewCardClient(c.config)
 	c.Group = NewGroupClient(c.config)
 	c.Ma = NewMaClient(c.config)
+	c.Sev = NewSevClient(c.config)
 	c.Ue = NewUeClient(c.config)
 	c.User = NewUserClient(c.config)
 }
@@ -140,6 +144,7 @@ func (c *Client) Tx(ctx context.Context) (*Tx, error) {
 		Card:   NewCardClient(cfg),
 		Group:  NewGroupClient(cfg),
 		Ma:     NewMaClient(cfg),
+		Sev:    NewSevClient(cfg),
 		Ue:     NewUeClient(cfg),
 		User:   NewUserClient(cfg),
 	}, nil
@@ -164,6 +169,7 @@ func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error)
 		Card:   NewCardClient(cfg),
 		Group:  NewGroupClient(cfg),
 		Ma:     NewMaClient(cfg),
+		Sev:    NewSevClient(cfg),
 		Ue:     NewUeClient(cfg),
 		User:   NewUserClient(cfg),
 	}, nil
@@ -194,21 +200,21 @@ func (c *Client) Close() error {
 // Use adds the mutation hooks to all the entity clients.
 // In order to add hooks to a specific client, call: `client.Node.Use(...)`.
 func (c *Client) Use(hooks ...Hook) {
-	c.Card.Use(hooks...)
-	c.Group.Use(hooks...)
-	c.Ma.Use(hooks...)
-	c.Ue.Use(hooks...)
-	c.User.Use(hooks...)
+	for _, n := range []interface{ Use(...Hook) }{
+		c.Card, c.Group, c.Ma, c.Sev, c.Ue, c.User,
+	} {
+		n.Use(hooks...)
+	}
 }
 
 // Intercept adds the query interceptors to all the entity clients.
 // In order to add interceptors to a specific client, call: `client.Node.Intercept(...)`.
 func (c *Client) Intercept(interceptors ...Interceptor) {
-	c.Card.Intercept(interceptors...)
-	c.Group.Intercept(interceptors...)
-	c.Ma.Intercept(interceptors...)
-	c.Ue.Intercept(interceptors...)
-	c.User.Intercept(interceptors...)
+	for _, n := range []interface{ Intercept(...Interceptor) }{
+		c.Card, c.Group, c.Ma, c.Sev, c.Ue, c.User,
+	} {
+		n.Intercept(interceptors...)
+	}
 }
 
 // Mutate implements the ent.Mutator interface.
@@ -220,6 +226,8 @@ func (c *Client) Mutate(ctx context.Context, m Mutation) (Value, error) {
 		return c.Group.mutate(ctx, m)
 	case *MaMutation:
 		return c.Ma.mutate(ctx, m)
+	case *SevMutation:
+		return c.Sev.mutate(ctx, m)
 	case *UeMutation:
 		return c.Ue.mutate(ctx, m)
 	case *UserMutation:
@@ -631,6 +639,140 @@ func (c *MaClient) mutate(ctx context.Context, m *MaMutation) (Value, error) {
 	}
 }
 
+// SevClient is a client for the Sev schema.
+type SevClient struct {
+	config
+}
+
+// NewSevClient returns a client for the Sev from the given config.
+func NewSevClient(c config) *SevClient {
+	return &SevClient{config: c}
+}
+
+// Use adds a list of mutation hooks to the hooks stack.
+// A call to `Use(f, g, h)` equals to `sev.Hooks(f(g(h())))`.
+func (c *SevClient) Use(hooks ...Hook) {
+	c.hooks.Sev = append(c.hooks.Sev, hooks...)
+}
+
+// Intercept adds a list of query interceptors to the interceptors stack.
+// A call to `Intercept(f, g, h)` equals to `sev.Intercept(f(g(h())))`.
+func (c *SevClient) Intercept(interceptors ...Interceptor) {
+	c.inters.Sev = append(c.inters.Sev, interceptors...)
+}
+
+// Create returns a builder for creating a Sev entity.
+func (c *SevClient) Create() *SevCreate {
+	mutation := newSevMutation(c.config, OpCreate)
+	return &SevCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// CreateBulk returns a builder for creating a bulk of Sev entities.
+func (c *SevClient) CreateBulk(builders ...*SevCreate) *SevCreateBulk {
+	return &SevCreateBulk{config: c.config, builders: builders}
+}
+
+// Update returns an update builder for Sev.
+func (c *SevClient) Update() *SevUpdate {
+	mutation := newSevMutation(c.config, OpUpdate)
+	return &SevUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOne returns an update builder for the given entity.
+func (c *SevClient) UpdateOne(s *Sev) *SevUpdateOne {
+	mutation := newSevMutation(c.config, OpUpdateOne, withSev(s))
+	return &SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// UpdateOneID returns an update builder for the given id.
+func (c *SevClient) UpdateOneID(id int) *SevUpdateOne {
+	mutation := newSevMutation(c.config, OpUpdateOne, withSevID(id))
+	return &SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// Delete returns a delete builder for Sev.
+func (c *SevClient) Delete() *SevDelete {
+	mutation := newSevMutation(c.config, OpDelete)
+	return &SevDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
+}
+
+// DeleteOne returns a builder for deleting the given entity.
+func (c *SevClient) DeleteOne(s *Sev) *SevDeleteOne {
+	return c.DeleteOneID(s.ID)
+}
+
+// DeleteOneID returns a builder for deleting the given entity by its id.
+func (c *SevClient) DeleteOneID(id int) *SevDeleteOne {
+	builder := c.Delete().Where(sev.ID(id))
+	builder.mutation.id = &id
+	builder.mutation.op = OpDeleteOne
+	return &SevDeleteOne{builder}
+}
+
+// Query returns a query builder for Sev.
+func (c *SevClient) Query() *SevQuery {
+	return &SevQuery{
+		config: c.config,
+		ctx:    &QueryContext{Type: TypeSev},
+		inters: c.Interceptors(),
+	}
+}
+
+// Get returns a Sev entity by its id.
+func (c *SevClient) Get(ctx context.Context, id int) (*Sev, error) {
+	return c.Query().Where(sev.ID(id)).Only(ctx)
+}
+
+// GetX is like Get, but panics if an error occurs.
+func (c *SevClient) GetX(ctx context.Context, id int) *Sev {
+	obj, err := c.Get(ctx, id)
+	if err != nil {
+		panic(err)
+	}
+	return obj
+}
+
+// QueryOwner queries the owner edge of a Sev.
+func (c *SevClient) QueryOwner(s *Sev) *UserQuery {
+	query := (&UserClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := s.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(sev.Table, sev.FieldID, id),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, sev.OwnerTable, sev.OwnerColumn),
+		)
+		fromV = sqlgraph.Neighbors(s.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
+// Hooks returns the client hooks.
+func (c *SevClient) Hooks() []Hook {
+	return c.hooks.Sev
+}
+
+// Interceptors returns the client interceptors.
+func (c *SevClient) Interceptors() []Interceptor {
+	return c.inters.Sev
+}
+
+func (c *SevClient) mutate(ctx context.Context, m *SevMutation) (Value, error) {
+	switch m.Op() {
+	case OpCreate:
+		return (&SevCreate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdate:
+		return (&SevUpdate{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpUpdateOne:
+		return (&SevUpdateOne{config: c.config, hooks: c.Hooks(), mutation: m}).Save(ctx)
+	case OpDelete, OpDeleteOne:
+		return (&SevDelete{config: c.config, hooks: c.Hooks(), mutation: m}).Exec(ctx)
+	default:
+		return nil, fmt.Errorf("ent: unknown Sev mutation op: %q", m.Op())
+	}
+}
+
 // UeClient is a client for the Ue schema.
 type UeClient struct {
 	config
@@ -906,6 +1048,22 @@ func (c *UserClient) QueryMa(u *User) *MaQuery {
 	return query
 }
 
+// QuerySev queries the sev edge of a User.
+func (c *UserClient) QuerySev(u *User) *SevQuery {
+	query := (&SevClient{config: c.config}).Query()
+	query.path = func(context.Context) (fromV *sql.Selector, _ error) {
+		id := u.ID
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, id),
+			sqlgraph.To(sev.Table, sev.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SevTable, user.SevColumn),
+		)
+		fromV = sqlgraph.Neighbors(u.driver.Dialect(), step)
+		return fromV, nil
+	}
+	return query
+}
+
 // Hooks returns the client hooks.
 func (c *UserClient) Hooks() []Hook {
 	return c.hooks.User
@@ -934,9 +1092,9 @@ func (c *UserClient) mutate(ctx context.Context, m *UserMutation) (Value, error)
 // hooks and interceptors per client, for fast access.
 type (
 	hooks struct {
-		Card, Group, Ma, Ue, User []ent.Hook
+		Card, Group, Ma, Sev, Ue, User []ent.Hook
 	}
 	inters struct {
-		Card, Group, Ma, Ue, User []ent.Interceptor
+		Card, Group, Ma, Sev, Ue, User []ent.Interceptor
 	}
 )

ent/ent.go

@@ -6,6 +6,7 @@ import (
 	"api/ent/card"
 	"api/ent/group"
 	"api/ent/ma"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 	"context"
@@ -80,6 +81,7 @@ func checkColumn(table, column string) error {
 			card.Table:  card.ValidColumn,
 			group.Table: group.ValidColumn,
 			ma.Table:    ma.ValidColumn,
+			sev.Table:   sev.ValidColumn,
 			ue.Table:    ue.ValidColumn,
 			user.Table:  user.ValidColumn,
 		})

ent/hook/hook.go

@@ -44,6 +44,18 @@ func (f MaFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
 	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.MaMutation", m)
 }
 
+// The SevFunc type is an adapter to allow the use of ordinary
+// function as Sev mutator.
+type SevFunc func(context.Context, *ent.SevMutation) (ent.Value, error)
+
+// Mutate calls f(ctx, m).
+func (f SevFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
+	if mv, ok := m.(*ent.SevMutation); ok {
+		return f(ctx, mv)
+	}
+	return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.SevMutation", m)
+}
+
 // The UeFunc type is an adapter to allow the use of ordinary
 // function as Ue mutator.
 type UeFunc func(context.Context, *ent.UeMutation) (ent.Value, error)

ent/migrate/schema.go

@@ -89,6 +89,37 @@ var (
 			},
 		},
 	}
+	// SevsColumns holds the columns for the "sevs" table.
+	SevsColumns = []*schema.Column{
+		{Name: "id", Type: field.TypeInt, Increment: true},
+		{Name: "password", Type: field.TypeString},
+		{Name: "token", Type: field.TypeString, Nullable: true},
+		{Name: "limit", Type: field.TypeBool, Nullable: true, Default: false},
+		{Name: "count", Type: field.TypeInt, Nullable: true},
+		{Name: "handle", Type: field.TypeString, Nullable: true},
+		{Name: "did", Type: field.TypeString, Nullable: true},
+		{Name: "uid", Type: field.TypeInt, Nullable: true},
+		{Name: "cid", Type: field.TypeInt, Nullable: true},
+		{Name: "cp", Type: field.TypeInt, Nullable: true},
+		{Name: "card", Type: field.TypeInt, Nullable: true},
+		{Name: "updated_at", Type: field.TypeTime, Nullable: true},
+		{Name: "created_at", Type: field.TypeTime, Nullable: true},
+		{Name: "user_sev", Type: field.TypeInt},
+	}
+	// SevsTable holds the schema information for the "sevs" table.
+	SevsTable = &schema.Table{
+		Name:       "sevs",
+		Columns:    SevsColumns,
+		PrimaryKey: []*schema.Column{SevsColumns[0]},
+		ForeignKeys: []*schema.ForeignKey{
+			{
+				Symbol:     "sevs_users_sev",
+				Columns:    []*schema.Column{SevsColumns[13]},
+				RefColumns: []*schema.Column{UsersColumns[0]},
+				OnDelete:   schema.NoAction,
+			},
+		},
+	}
 	// UesColumns holds the columns for the "ues" table.
 	UesColumns = []*schema.Column{
 		{Name: "id", Type: field.TypeInt, Increment: true},
@@ -162,7 +193,7 @@ var (
 		{Name: "ten_post", Type: field.TypeString, Nullable: true},
 		{Name: "ten_get", Type: field.TypeString, Nullable: true},
 		{Name: "ten_at", Type: field.TypeTime, Nullable: true},
-		{Name: "next", Type: field.TypeString, Nullable: true, Default: "20240401"},
+		{Name: "next", Type: field.TypeString, Nullable: true, Default: "20240410"},
 		{Name: "room", Type: field.TypeInt, Nullable: true},
 		{Name: "model", Type: field.TypeBool, Nullable: true},
 		{Name: "model_at", Type: field.TypeTime, Nullable: true},
@@ -208,6 +239,7 @@ var (
 		CardsTable,
 		GroupsTable,
 		MasTable,
+		SevsTable,
 		UesTable,
 		UsersTable,
 	}
@@ -216,6 +248,7 @@ var (
 func init() {
 	CardsTable.ForeignKeys[0].RefTable = UsersTable
 	MasTable.ForeignKeys[0].RefTable = UsersTable
+	SevsTable.ForeignKeys[0].RefTable = UsersTable
 	UesTable.ForeignKeys[0].RefTable = UsersTable
 	UsersTable.ForeignKeys[0].RefTable = GroupsTable
 }

ent/ogent/oas_client_gen.go

@@ -272,6 +272,77 @@ func (c *Client) sendCreateMa(ctx context.Context, request *CreateMaReq) (res Cr
 	return result, nil
 }
 
+// CreateSev invokes createSev operation.
+//
+// Creates a new Sev and persists it to storage.
+//
+// POST /sevs
+func (c *Client) CreateSev(ctx context.Context, request *CreateSevReq) (CreateSevRes, error) {
+	res, err := c.sendCreateSev(ctx, request)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendCreateSev(ctx context.Context, request *CreateSevReq) (res CreateSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("createSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "CreateSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs"
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "POST", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+	if err := encodeCreateSevRequest(request, r); err != nil {
+		return res, errors.Wrap(err, "encode request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeCreateSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // CreateUe invokes createUe operation.
 //
 // Creates a new Ue and persists it to storage.
@@ -660,6 +731,88 @@ func (c *Client) sendDeleteMa(ctx context.Context, params DeleteMaParams) (res D
 	return result, nil
 }
 
+// DeleteSev invokes deleteSev operation.
+//
+// Deletes the Sev with the requested ID.
+//
+// DELETE /sevs/{id}
+func (c *Client) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) {
+	res, err := c.sendDeleteSev(ctx, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendDeleteSev(ctx context.Context, params DeleteSevParams) (res DeleteSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("deleteSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "DeleteSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs/"
+	{
+		// Encode "id" parameter.
+		e := uri.NewPathEncoder(uri.PathEncoderConfig{
+			Param:   "id",
+			Style:   uri.PathStyleSimple,
+			Explode: false,
+		})
+		if err := func() error {
+			return e.EncodeValue(conv.IntToString(params.ID))
+		}(); err != nil {
+			return res, errors.Wrap(err, "encode path")
+		}
+		u.Path += e.Result()
+	}
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "DELETE", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeDeleteSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // DeleteUe invokes deleteUe operation.
 //
 // Deletes the Ue with the requested ID.
@@ -1429,6 +1582,112 @@ func (c *Client) sendListMa(ctx context.Context, params ListMaParams) (res ListM
 	return result, nil
 }
 
+// ListSev invokes listSev operation.
+//
+// List Sevs.
+//
+// GET /sevs
+func (c *Client) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) {
+	res, err := c.sendListSev(ctx, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendListSev(ctx context.Context, params ListSevParams) (res ListSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("listSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "ListSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs"
+
+	stage = "EncodeQueryParams"
+	q := uri.NewQueryEncoder()
+	{
+		// Encode "page" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "page",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Page.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "itemsPerPage" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "itemsPerPage",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.ItemsPerPage.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	u.RawQuery = q.Values().Encode()
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "GET", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeListSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // ListUe invokes listUe operation.
 //
 // List Ues.
@@ -1883,6 +2142,127 @@ func (c *Client) sendListUserMa(ctx context.Context, params ListUserMaParams) (r
 	return result, nil
 }
 
+// ListUserSev invokes listUserSev operation.
+//
+// List attached Sevs.
+//
+// GET /users/{id}/sev
+func (c *Client) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) {
+	res, err := c.sendListUserSev(ctx, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendListUserSev(ctx context.Context, params ListUserSevParams) (res ListUserSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("listUserSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "ListUserSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/users/"
+	{
+		// Encode "id" parameter.
+		e := uri.NewPathEncoder(uri.PathEncoderConfig{
+			Param:   "id",
+			Style:   uri.PathStyleSimple,
+			Explode: false,
+		})
+		if err := func() error {
+			return e.EncodeValue(conv.IntToString(params.ID))
+		}(); err != nil {
+			return res, errors.Wrap(err, "encode path")
+		}
+		u.Path += e.Result()
+	}
+	u.Path += "/sev"
+
+	stage = "EncodeQueryParams"
+	q := uri.NewQueryEncoder()
+	{
+		// Encode "page" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "page",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.Page.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	{
+		// Encode "itemsPerPage" parameter.
+		cfg := uri.QueryParameterEncodingConfig{
+			Name:    "itemsPerPage",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.EncodeParam(cfg, func(e uri.Encoder) error {
+			if val, ok := params.ItemsPerPage.Get(); ok {
+				return e.EncodeValue(conv.IntToString(val))
+			}
+			return nil
+		}); err != nil {
+			return res, errors.Wrap(err, "encode query")
+		}
+	}
+	u.RawQuery = q.Values().Encode()
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "GET", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeListUserSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // ListUserUe invokes listUserUe operation.
 //
 // List attached Ues.
@@ -2416,6 +2796,171 @@ func (c *Client) sendReadMaOwner(ctx context.Context, params ReadMaOwnerParams)
 	return result, nil
 }
 
+// ReadSev invokes readSev operation.
+//
+// Finds the Sev with the requested ID and returns it.
+//
+// GET /sevs/{id}
+func (c *Client) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) {
+	res, err := c.sendReadSev(ctx, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendReadSev(ctx context.Context, params ReadSevParams) (res ReadSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("readSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "ReadSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs/"
+	{
+		// Encode "id" parameter.
+		e := uri.NewPathEncoder(uri.PathEncoderConfig{
+			Param:   "id",
+			Style:   uri.PathStyleSimple,
+			Explode: false,
+		})
+		if err := func() error {
+			return e.EncodeValue(conv.IntToString(params.ID))
+		}(); err != nil {
+			return res, errors.Wrap(err, "encode path")
+		}
+		u.Path += e.Result()
+	}
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "GET", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeReadSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
+// ReadSevOwner invokes readSevOwner operation.
+//
+// Find the attached User of the Sev with the given ID.
+//
+// GET /sevs/{id}/owner
+func (c *Client) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) {
+	res, err := c.sendReadSevOwner(ctx, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (res ReadSevOwnerRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("readSevOwner"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "ReadSevOwner",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs/"
+	{
+		// Encode "id" parameter.
+		e := uri.NewPathEncoder(uri.PathEncoderConfig{
+			Param:   "id",
+			Style:   uri.PathStyleSimple,
+			Explode: false,
+		})
+		if err := func() error {
+			return e.EncodeValue(conv.IntToString(params.ID))
+		}(); err != nil {
+			return res, errors.Wrap(err, "encode path")
+		}
+		u.Path += e.Result()
+	}
+	u.Path += "/owner"
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "GET", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeReadSevOwnerResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // ReadUe invokes readUe operation.
 //
 // Finds the Ue with the requested ID and returns it.
@@ -2918,6 +3463,91 @@ func (c *Client) sendUpdateMa(ctx context.Context, request *UpdateMaReq, params
 	return result, nil
 }
 
+// UpdateSev invokes updateSev operation.
+//
+// Updates a Sev and persists changes to storage.
+//
+// PATCH /sevs/{id}
+func (c *Client) UpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) {
+	res, err := c.sendUpdateSev(ctx, request, params)
+	_ = res
+	return res, err
+}
+
+func (c *Client) sendUpdateSev(ctx context.Context, request *UpdateSevReq, params UpdateSevParams) (res UpdateSevRes, err error) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("updateSev"),
+	}
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		c.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	c.requests.Add(ctx, 1, otelAttrs...)
+
+	// Start a span for this request.
+	ctx, span := c.cfg.Tracer.Start(ctx, "UpdateSev",
+		trace.WithAttributes(otelAttrs...),
+		clientSpanKind,
+	)
+	// Track stage for error reporting.
+	var stage string
+	defer func() {
+		if err != nil {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			c.errors.Add(ctx, 1, otelAttrs...)
+		}
+		span.End()
+	}()
+
+	stage = "BuildURL"
+	u := uri.Clone(c.requestURL(ctx))
+	u.Path += "/sevs/"
+	{
+		// Encode "id" parameter.
+		e := uri.NewPathEncoder(uri.PathEncoderConfig{
+			Param:   "id",
+			Style:   uri.PathStyleSimple,
+			Explode: false,
+		})
+		if err := func() error {
+			return e.EncodeValue(conv.IntToString(params.ID))
+		}(); err != nil {
+			return res, errors.Wrap(err, "encode path")
+		}
+		u.Path += e.Result()
+	}
+
+	stage = "EncodeRequest"
+	r, err := ht.NewRequest(ctx, "PATCH", u, nil)
+	if err != nil {
+		return res, errors.Wrap(err, "create request")
+	}
+	if err := encodeUpdateSevRequest(request, r); err != nil {
+		return res, errors.Wrap(err, "encode request")
+	}
+
+	stage = "SendRequest"
+	resp, err := c.cfg.Client.Do(r)
+	if err != nil {
+		return res, errors.Wrap(err, "do request")
+	}
+	defer resp.Body.Close()
+
+	stage = "DecodeResponse"
+	result, err := decodeUpdateSevResponse(resp)
+	if err != nil {
+		return res, errors.Wrap(err, "decode response")
+	}
+
+	return result, nil
+}
+
 // UpdateUe invokes updateUe operation.
 //
 // Updates a Ue and persists changes to storage.

ent/ogent/oas_handlers_gen.go

@@ -323,6 +323,108 @@ func (s *Server) handleCreateMaRequest(args [0]string, w http.ResponseWriter, r
 	}
 }
 
+// handleCreateSevRequest handles createSev operation.
+//
+// Creates a new Sev and persists it to storage.
+//
+// POST /sevs
+func (s *Server) handleCreateSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("createSev"),
+		semconv.HTTPMethodKey.String("POST"),
+		semconv.HTTPRouteKey.String("/sevs"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "CreateSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "CreateSev",
+			ID:   "createSev",
+		}
+	)
+	request, close, err := s.decodeCreateSevRequest(r)
+	if err != nil {
+		err = &ogenerrors.DecodeRequestError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeRequest", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+	defer func() {
+		if err := close(); err != nil {
+			recordError("CloseRequest", err)
+		}
+	}()
+
+	var response CreateSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "CreateSev",
+			OperationID:   "createSev",
+			Body:          request,
+			Params:        middleware.Parameters{},
+			Raw:           r,
+		}
+
+		type (
+			Request  = *CreateSevReq
+			Params   = struct{}
+			Response = CreateSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			nil,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.CreateSev(ctx, request)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.CreateSev(ctx, request)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeCreateSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleCreateUeRequest handles createUe operation.
 //
 // Creates a new Ue and persists it to storage.
@@ -833,6 +935,108 @@ func (s *Server) handleDeleteMaRequest(args [1]string, w http.ResponseWriter, r
 	}
 }
 
+// handleDeleteSevRequest handles deleteSev operation.
+//
+// Deletes the Sev with the requested ID.
+//
+// DELETE /sevs/{id}
+func (s *Server) handleDeleteSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("deleteSev"),
+		semconv.HTTPMethodKey.String("DELETE"),
+		semconv.HTTPRouteKey.String("/sevs/{id}"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "DeleteSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "DeleteSev",
+			ID:   "deleteSev",
+		}
+	)
+	params, err := decodeDeleteSevParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	var response DeleteSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "DeleteSev",
+			OperationID:   "deleteSev",
+			Body:          nil,
+			Params: middleware.Parameters{
+				{
+					Name: "id",
+					In:   "path",
+				}: params.ID,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = struct{}
+			Params   = DeleteSevParams
+			Response = DeleteSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackDeleteSevParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.DeleteSev(ctx, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.DeleteSev(ctx, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeDeleteSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleDeleteUeRequest handles deleteUe operation.
 //
 // Deletes the Ue with the requested ID.
@@ -1669,6 +1873,112 @@ func (s *Server) handleListMaRequest(args [0]string, w http.ResponseWriter, r *h
 	}
 }
 
+// handleListSevRequest handles listSev operation.
+//
+// List Sevs.
+//
+// GET /sevs
+func (s *Server) handleListSevRequest(args [0]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("listSev"),
+		semconv.HTTPMethodKey.String("GET"),
+		semconv.HTTPRouteKey.String("/sevs"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "ListSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "ListSev",
+			ID:   "listSev",
+		}
+	)
+	params, err := decodeListSevParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	var response ListSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "ListSev",
+			OperationID:   "listSev",
+			Body:          nil,
+			Params: middleware.Parameters{
+				{
+					Name: "page",
+					In:   "query",
+				}: params.Page,
+				{
+					Name: "itemsPerPage",
+					In:   "query",
+				}: params.ItemsPerPage,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = struct{}
+			Params   = ListSevParams
+			Response = ListSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackListSevParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.ListSev(ctx, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.ListSev(ctx, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeListSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleListUeRequest handles listUe operation.
 //
 // List Ues.
@@ -2101,6 +2411,116 @@ func (s *Server) handleListUserMaRequest(args [1]string, w http.ResponseWriter,
 	}
 }
 
+// handleListUserSevRequest handles listUserSev operation.
+//
+// List attached Sevs.
+//
+// GET /users/{id}/sev
+func (s *Server) handleListUserSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("listUserSev"),
+		semconv.HTTPMethodKey.String("GET"),
+		semconv.HTTPRouteKey.String("/users/{id}/sev"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "ListUserSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "ListUserSev",
+			ID:   "listUserSev",
+		}
+	)
+	params, err := decodeListUserSevParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	var response ListUserSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "ListUserSev",
+			OperationID:   "listUserSev",
+			Body:          nil,
+			Params: middleware.Parameters{
+				{
+					Name: "id",
+					In:   "path",
+				}: params.ID,
+				{
+					Name: "page",
+					In:   "query",
+				}: params.Page,
+				{
+					Name: "itemsPerPage",
+					In:   "query",
+				}: params.ItemsPerPage,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = struct{}
+			Params   = ListUserSevParams
+			Response = ListUserSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackListUserSevParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.ListUserSev(ctx, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.ListUserSev(ctx, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeListUserSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleListUserUeRequest handles listUserUe operation.
 //
 // List attached Ues.
@@ -2721,6 +3141,210 @@ func (s *Server) handleReadMaOwnerRequest(args [1]string, w http.ResponseWriter,
 	}
 }
 
+// handleReadSevRequest handles readSev operation.
+//
+// Finds the Sev with the requested ID and returns it.
+//
+// GET /sevs/{id}
+func (s *Server) handleReadSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("readSev"),
+		semconv.HTTPMethodKey.String("GET"),
+		semconv.HTTPRouteKey.String("/sevs/{id}"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "ReadSev",
+			ID:   "readSev",
+		}
+	)
+	params, err := decodeReadSevParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	var response ReadSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "ReadSev",
+			OperationID:   "readSev",
+			Body:          nil,
+			Params: middleware.Parameters{
+				{
+					Name: "id",
+					In:   "path",
+				}: params.ID,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = struct{}
+			Params   = ReadSevParams
+			Response = ReadSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackReadSevParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.ReadSev(ctx, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.ReadSev(ctx, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeReadSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
+// handleReadSevOwnerRequest handles readSevOwner operation.
+//
+// Find the attached User of the Sev with the given ID.
+//
+// GET /sevs/{id}/owner
+func (s *Server) handleReadSevOwnerRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("readSevOwner"),
+		semconv.HTTPMethodKey.String("GET"),
+		semconv.HTTPRouteKey.String("/sevs/{id}/owner"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "ReadSevOwner",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "ReadSevOwner",
+			ID:   "readSevOwner",
+		}
+	)
+	params, err := decodeReadSevOwnerParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	var response ReadSevOwnerRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "ReadSevOwner",
+			OperationID:   "readSevOwner",
+			Body:          nil,
+			Params: middleware.Parameters{
+				{
+					Name: "id",
+					In:   "path",
+				}: params.ID,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = struct{}
+			Params   = ReadSevOwnerParams
+			Response = ReadSevOwnerRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackReadSevOwnerParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.ReadSevOwner(ctx, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.ReadSevOwner(ctx, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeReadSevOwnerResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleReadUeRequest handles readUe operation.
 //
 // Finds the Ue with the requested ID and returns it.
@@ -3378,6 +4002,123 @@ func (s *Server) handleUpdateMaRequest(args [1]string, w http.ResponseWriter, r
 	}
 }
 
+// handleUpdateSevRequest handles updateSev operation.
+//
+// Updates a Sev and persists changes to storage.
+//
+// PATCH /sevs/{id}
+func (s *Server) handleUpdateSevRequest(args [1]string, w http.ResponseWriter, r *http.Request) {
+	otelAttrs := []attribute.KeyValue{
+		otelogen.OperationID("updateSev"),
+		semconv.HTTPMethodKey.String("PATCH"),
+		semconv.HTTPRouteKey.String("/sevs/{id}"),
+	}
+
+	// Start a span for this request.
+	ctx, span := s.cfg.Tracer.Start(r.Context(), "UpdateSev",
+		trace.WithAttributes(otelAttrs...),
+		serverSpanKind,
+	)
+	defer span.End()
+
+	// Run stopwatch.
+	startTime := time.Now()
+	defer func() {
+		elapsedDuration := time.Since(startTime)
+		s.duration.Record(ctx, elapsedDuration.Microseconds(), otelAttrs...)
+	}()
+
+	// Increment request counter.
+	s.requests.Add(ctx, 1, otelAttrs...)
+
+	var (
+		recordError = func(stage string, err error) {
+			span.RecordError(err)
+			span.SetStatus(codes.Error, stage)
+			s.errors.Add(ctx, 1, otelAttrs...)
+		}
+		err          error
+		opErrContext = ogenerrors.OperationContext{
+			Name: "UpdateSev",
+			ID:   "updateSev",
+		}
+	)
+	params, err := decodeUpdateSevParams(args, r)
+	if err != nil {
+		err = &ogenerrors.DecodeParamsError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeParams", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+	request, close, err := s.decodeUpdateSevRequest(r)
+	if err != nil {
+		err = &ogenerrors.DecodeRequestError{
+			OperationContext: opErrContext,
+			Err:              err,
+		}
+		recordError("DecodeRequest", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+	defer func() {
+		if err := close(); err != nil {
+			recordError("CloseRequest", err)
+		}
+	}()
+
+	var response UpdateSevRes
+	if m := s.cfg.Middleware; m != nil {
+		mreq := middleware.Request{
+			Context:       ctx,
+			OperationName: "UpdateSev",
+			OperationID:   "updateSev",
+			Body:          request,
+			Params: middleware.Parameters{
+				{
+					Name: "id",
+					In:   "path",
+				}: params.ID,
+			},
+			Raw: r,
+		}
+
+		type (
+			Request  = *UpdateSevReq
+			Params   = UpdateSevParams
+			Response = UpdateSevRes
+		)
+		response, err = middleware.HookMiddleware[
+			Request,
+			Params,
+			Response,
+		](
+			m,
+			mreq,
+			unpackUpdateSevParams,
+			func(ctx context.Context, request Request, params Params) (response Response, err error) {
+				response, err = s.h.UpdateSev(ctx, request, params)
+				return response, err
+			},
+		)
+	} else {
+		response, err = s.h.UpdateSev(ctx, request, params)
+	}
+	if err != nil {
+		recordError("Internal", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+
+	if err := encodeUpdateSevResponse(response, w, span); err != nil {
+		recordError("EncodeResponse", err)
+		s.cfg.ErrorHandler(ctx, w, r, err)
+		return
+	}
+}
+
 // handleUpdateUeRequest handles updateUe operation.
 //
 // Updates a Ue and persists changes to storage.

ent/ogent/oas_interfaces_gen.go

@@ -13,6 +13,10 @@ type CreateMaRes interface {
 	createMaRes()
 }
 
+type CreateSevRes interface {
+	createSevRes()
+}
+
 type CreateUeRes interface {
 	createUeRes()
 }
@@ -33,6 +37,10 @@ type DeleteMaRes interface {
 	deleteMaRes()
 }
 
+type DeleteSevRes interface {
+	deleteSevRes()
+}
+
 type DeleteUeRes interface {
 	deleteUeRes()
 }
@@ -57,6 +65,10 @@ type ListMaRes interface {
 	listMaRes()
 }
 
+type ListSevRes interface {
+	listSevRes()
+}
+
 type ListUeRes interface {
 	listUeRes()
 }
@@ -73,6 +85,10 @@ type ListUserRes interface {
 	listUserRes()
 }
 
+type ListUserSevRes interface {
+	listUserSevRes()
+}
+
 type ListUserUeRes interface {
 	listUserUeRes()
 }
@@ -97,6 +113,14 @@ type ReadMaRes interface {
 	readMaRes()
 }
 
+type ReadSevOwnerRes interface {
+	readSevOwnerRes()
+}
+
+type ReadSevRes interface {
+	readSevRes()
+}
+
 type ReadUeOwnerRes interface {
 	readUeOwnerRes()
 }
@@ -121,6 +145,10 @@ type UpdateMaRes interface {
 	updateMaRes()
 }
 
+type UpdateSevRes interface {
+	updateSevRes()
+}
+
 type UpdateUeRes interface {
 	updateUeRes()
 }

ent/ogent/oas_parameters_gen.go

@@ -201,6 +201,68 @@ func decodeDeleteMaParams(args [1]string, r *http.Request) (params DeleteMaParam
 	return params, nil
 }
 
+// DeleteSevParams is parameters of deleteSev operation.
+type DeleteSevParams struct {
+	// ID of the Sev.
+	ID int
+}
+
+func unpackDeleteSevParams(packed middleware.Parameters) (params DeleteSevParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "id",
+			In:   "path",
+		}
+		params.ID = packed[key].(int)
+	}
+	return params
+}
+
+func decodeDeleteSevParams(args [1]string, r *http.Request) (params DeleteSevParams, _ error) {
+	// Decode path: id.
+	if err := func() error {
+		param, err := url.PathUnescape(args[0])
+		if err != nil {
+			return errors.Wrap(err, "unescape path")
+		}
+		if len(param) > 0 {
+			d := uri.NewPathDecoder(uri.PathDecoderConfig{
+				Param:   "id",
+				Value:   param,
+				Style:   uri.PathStyleSimple,
+				Explode: false,
+			})
+
+			if err := func() error {
+				val, err := d.DecodeValue()
+				if err != nil {
+					return err
+				}
+
+				c, err := conv.ToInt(val)
+				if err != nil {
+					return err
+				}
+
+				params.ID = c
+				return nil
+			}(); err != nil {
+				return err
+			}
+		} else {
+			return validate.ErrFieldRequired
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "id",
+			In:   "path",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
 // DeleteUeParams is parameters of deleteUe operation.
 type DeleteUeParams struct {
 	// ID of the Ue.
@@ -1109,6 +1171,171 @@ func decodeListMaParams(args [0]string, r *http.Request) (params ListMaParams, _
 	return params, nil
 }
 
+// ListSevParams is parameters of listSev operation.
+type ListSevParams struct {
+	// What page to render.
+	Page OptInt
+	// Item count to render per page.
+	ItemsPerPage OptInt
+}
+
+func unpackListSevParams(packed middleware.Parameters) (params ListSevParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "page",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.Page = v.(OptInt)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "itemsPerPage",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.ItemsPerPage = v.(OptInt)
+		}
+	}
+	return params
+}
+
+func decodeListSevParams(args [0]string, r *http.Request) (params ListSevParams, _ error) {
+	q := uri.NewQueryDecoder(r.URL.Query())
+	// Decode query: page.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "page",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotPageVal int
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToInt(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotPageVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.Page.SetTo(paramsDotPageVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+			if err := func() error {
+				if params.Page.Set {
+					if err := func() error {
+						if err := (validate.Int{
+							MinSet:        true,
+							Min:           1,
+							MaxSet:        false,
+							Max:           0,
+							MinExclusive:  false,
+							MaxExclusive:  false,
+							MultipleOfSet: false,
+							MultipleOf:    0,
+						}).Validate(int64(params.Page.Value)); err != nil {
+							return errors.Wrap(err, "int")
+						}
+						return nil
+					}(); err != nil {
+						return err
+					}
+				}
+				return nil
+			}(); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "page",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	// Decode query: itemsPerPage.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "itemsPerPage",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotItemsPerPageVal int
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToInt(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotItemsPerPageVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+			if err := func() error {
+				if params.ItemsPerPage.Set {
+					if err := func() error {
+						if err := (validate.Int{
+							MinSet:        true,
+							Min:           1,
+							MaxSet:        true,
+							Max:           5000,
+							MinExclusive:  false,
+							MaxExclusive:  false,
+							MultipleOfSet: false,
+							MultipleOf:    0,
+						}).Validate(int64(params.ItemsPerPage.Value)); err != nil {
+							return errors.Wrap(err, "int")
+						}
+						return nil
+					}(); err != nil {
+						return err
+					}
+				}
+				return nil
+			}(); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "itemsPerPage",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
 // ListUeParams is parameters of listUe operation.
 type ListUeParams struct {
 	// What page to render.
@@ -1773,6 +2000,173 @@ func decodeListUserMaParams(args [1]string, r *http.Request) (params ListUserMaP
 	return params, nil
 }
 
+// ListUserSevParams is parameters of listUserSev operation.
+type ListUserSevParams struct {
+	// ID of the User.
+	ID int
+	// What page to render.
+	Page OptInt
+	// Item count to render per page.
+	ItemsPerPage OptInt
+}
+
+func unpackListUserSevParams(packed middleware.Parameters) (params ListUserSevParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "id",
+			In:   "path",
+		}
+		params.ID = packed[key].(int)
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "page",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.Page = v.(OptInt)
+		}
+	}
+	{
+		key := middleware.ParameterKey{
+			Name: "itemsPerPage",
+			In:   "query",
+		}
+		if v, ok := packed[key]; ok {
+			params.ItemsPerPage = v.(OptInt)
+		}
+	}
+	return params
+}
+
+func decodeListUserSevParams(args [1]string, r *http.Request) (params ListUserSevParams, _ error) {
+	q := uri.NewQueryDecoder(r.URL.Query())
+	// Decode path: id.
+	if err := func() error {
+		param, err := url.PathUnescape(args[0])
+		if err != nil {
+			return errors.Wrap(err, "unescape path")
+		}
+		if len(param) > 0 {
+			d := uri.NewPathDecoder(uri.PathDecoderConfig{
+				Param:   "id",
+				Value:   param,
+				Style:   uri.PathStyleSimple,
+				Explode: false,
+			})
+
+			if err := func() error {
+				val, err := d.DecodeValue()
+				if err != nil {
+					return err
+				}
+
+				c, err := conv.ToInt(val)
+				if err != nil {
+					return err
+				}
+
+				params.ID = c
+				return nil
+			}(); err != nil {
+				return err
+			}
+		} else {
+			return validate.ErrFieldRequired
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "id",
+			In:   "path",
+			Err:  err,
+		}
+	}
+	// Decode query: page.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "page",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotPageVal int
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToInt(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotPageVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.Page.SetTo(paramsDotPageVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "page",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	// Decode query: itemsPerPage.
+	if err := func() error {
+		cfg := uri.QueryParameterDecodingConfig{
+			Name:    "itemsPerPage",
+			Style:   uri.QueryStyleForm,
+			Explode: true,
+		}
+
+		if err := q.HasParam(cfg); err == nil {
+			if err := q.DecodeParam(cfg, func(d uri.Decoder) error {
+				var paramsDotItemsPerPageVal int
+				if err := func() error {
+					val, err := d.DecodeValue()
+					if err != nil {
+						return err
+					}
+
+					c, err := conv.ToInt(val)
+					if err != nil {
+						return err
+					}
+
+					paramsDotItemsPerPageVal = c
+					return nil
+				}(); err != nil {
+					return err
+				}
+				params.ItemsPerPage.SetTo(paramsDotItemsPerPageVal)
+				return nil
+			}); err != nil {
+				return err
+			}
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "itemsPerPage",
+			In:   "query",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
 // ListUserUeParams is parameters of listUserUe operation.
 type ListUserUeParams struct {
 	// ID of the User.
@@ -2250,6 +2644,130 @@ func decodeReadMaOwnerParams(args [1]string, r *http.Request) (params ReadMaOwne
 	return params, nil
 }
 
+// ReadSevParams is parameters of readSev operation.
+type ReadSevParams struct {
+	// ID of the Sev.
+	ID int
+}
+
+func unpackReadSevParams(packed middleware.Parameters) (params ReadSevParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "id",
+			In:   "path",
+		}
+		params.ID = packed[key].(int)
+	}
+	return params
+}
+
+func decodeReadSevParams(args [1]string, r *http.Request) (params ReadSevParams, _ error) {
+	// Decode path: id.
+	if err := func() error {
+		param, err := url.PathUnescape(args[0])
+		if err != nil {
+			return errors.Wrap(err, "unescape path")
+		}
+		if len(param) > 0 {
+			d := uri.NewPathDecoder(uri.PathDecoderConfig{
+				Param:   "id",
+				Value:   param,
+				Style:   uri.PathStyleSimple,
+				Explode: false,
+			})
+
+			if err := func() error {
+				val, err := d.DecodeValue()
+				if err != nil {
+					return err
+				}
+
+				c, err := conv.ToInt(val)
+				if err != nil {
+					return err
+				}
+
+				params.ID = c
+				return nil
+			}(); err != nil {
+				return err
+			}
+		} else {
+			return validate.ErrFieldRequired
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "id",
+			In:   "path",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
+// ReadSevOwnerParams is parameters of readSevOwner operation.
+type ReadSevOwnerParams struct {
+	// ID of the Sev.
+	ID int
+}
+
+func unpackReadSevOwnerParams(packed middleware.Parameters) (params ReadSevOwnerParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "id",
+			In:   "path",
+		}
+		params.ID = packed[key].(int)
+	}
+	return params
+}
+
+func decodeReadSevOwnerParams(args [1]string, r *http.Request) (params ReadSevOwnerParams, _ error) {
+	// Decode path: id.
+	if err := func() error {
+		param, err := url.PathUnescape(args[0])
+		if err != nil {
+			return errors.Wrap(err, "unescape path")
+		}
+		if len(param) > 0 {
+			d := uri.NewPathDecoder(uri.PathDecoderConfig{
+				Param:   "id",
+				Value:   param,
+				Style:   uri.PathStyleSimple,
+				Explode: false,
+			})
+
+			if err := func() error {
+				val, err := d.DecodeValue()
+				if err != nil {
+					return err
+				}
+
+				c, err := conv.ToInt(val)
+				if err != nil {
+					return err
+				}
+
+				params.ID = c
+				return nil
+			}(); err != nil {
+				return err
+			}
+		} else {
+			return validate.ErrFieldRequired
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "id",
+			In:   "path",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
 // ReadUeParams is parameters of readUe operation.
 type ReadUeParams struct {
 	// ID of the Ue.
@@ -2622,6 +3140,68 @@ func decodeUpdateMaParams(args [1]string, r *http.Request) (params UpdateMaParam
 	return params, nil
 }
 
+// UpdateSevParams is parameters of updateSev operation.
+type UpdateSevParams struct {
+	// ID of the Sev.
+	ID int
+}
+
+func unpackUpdateSevParams(packed middleware.Parameters) (params UpdateSevParams) {
+	{
+		key := middleware.ParameterKey{
+			Name: "id",
+			In:   "path",
+		}
+		params.ID = packed[key].(int)
+	}
+	return params
+}
+
+func decodeUpdateSevParams(args [1]string, r *http.Request) (params UpdateSevParams, _ error) {
+	// Decode path: id.
+	if err := func() error {
+		param, err := url.PathUnescape(args[0])
+		if err != nil {
+			return errors.Wrap(err, "unescape path")
+		}
+		if len(param) > 0 {
+			d := uri.NewPathDecoder(uri.PathDecoderConfig{
+				Param:   "id",
+				Value:   param,
+				Style:   uri.PathStyleSimple,
+				Explode: false,
+			})
+
+			if err := func() error {
+				val, err := d.DecodeValue()
+				if err != nil {
+					return err
+				}
+
+				c, err := conv.ToInt(val)
+				if err != nil {
+					return err
+				}
+
+				params.ID = c
+				return nil
+			}(); err != nil {
+				return err
+			}
+		} else {
+			return validate.ErrFieldRequired
+		}
+		return nil
+	}(); err != nil {
+		return params, &ogenerrors.DecodeParamError{
+			Name: "id",
+			In:   "path",
+			Err:  err,
+		}
+	}
+	return params, nil
+}
+
 // UpdateUeParams is parameters of updateUe operation.
 type UpdateUeParams struct {
 	// ID of the Ue.

ent/ogent/oas_request_decoders_gen.go

@@ -204,6 +204,69 @@ func (s *Server) decodeCreateMaRequest(r *http.Request) (
 	}
 }
 
+func (s *Server) decodeCreateSevRequest(r *http.Request) (
+	req *CreateSevReq,
+	close func() error,
+	rerr error,
+) {
+	var closers []func() error
+	close = func() error {
+		var merr error
+		// Close in reverse order, to match defer behavior.
+		for i := len(closers) - 1; i >= 0; i-- {
+			c := closers[i]
+			merr = multierr.Append(merr, c())
+		}
+		return merr
+	}
+	defer func() {
+		if rerr != nil {
+			rerr = multierr.Append(rerr, close())
+		}
+	}()
+	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		return req, close, errors.Wrap(err, "parse media type")
+	}
+	switch {
+	case ct == "application/json":
+		if r.ContentLength == 0 {
+			return req, close, validate.ErrBodyRequired
+		}
+		buf, err := io.ReadAll(r.Body)
+		if err != nil {
+			return req, close, err
+		}
+
+		if len(buf) == 0 {
+			return req, close, validate.ErrBodyRequired
+		}
+
+		d := jx.DecodeBytes(buf)
+
+		var request CreateSevReq
+		if err := func() error {
+			if err := request.Decode(d); err != nil {
+				return err
+			}
+			if err := d.Skip(); err != io.EOF {
+				return errors.New("unexpected trailing data")
+			}
+			return nil
+		}(); err != nil {
+			err = &ogenerrors.DecodeBodyError{
+				ContentType: ct,
+				Body:        buf,
+				Err:         err,
+			}
+			return req, close, err
+		}
+		return &request, close, nil
+	default:
+		return req, close, validate.InvalidContentType(ct)
+	}
+}
+
 func (s *Server) decodeCreateUeRequest(r *http.Request) (
 	req *CreateUeReq,
 	close func() error,
@@ -519,6 +582,69 @@ func (s *Server) decodeUpdateMaRequest(r *http.Request) (
 	}
 }
 
+func (s *Server) decodeUpdateSevRequest(r *http.Request) (
+	req *UpdateSevReq,
+	close func() error,
+	rerr error,
+) {
+	var closers []func() error
+	close = func() error {
+		var merr error
+		// Close in reverse order, to match defer behavior.
+		for i := len(closers) - 1; i >= 0; i-- {
+			c := closers[i]
+			merr = multierr.Append(merr, c())
+		}
+		return merr
+	}
+	defer func() {
+		if rerr != nil {
+			rerr = multierr.Append(rerr, close())
+		}
+	}()
+	ct, _, err := mime.ParseMediaType(r.Header.Get("Content-Type"))
+	if err != nil {
+		return req, close, errors.Wrap(err, "parse media type")
+	}
+	switch {
+	case ct == "application/json":
+		if r.ContentLength == 0 {
+			return req, close, validate.ErrBodyRequired
+		}
+		buf, err := io.ReadAll(r.Body)
+		if err != nil {
+			return req, close, err
+		}
+
+		if len(buf) == 0 {
+			return req, close, validate.ErrBodyRequired
+		}
+
+		d := jx.DecodeBytes(buf)
+
+		var request UpdateSevReq
+		if err := func() error {
+			if err := request.Decode(d); err != nil {
+				return err
+			}
+			if err := d.Skip(); err != io.EOF {
+				return errors.New("unexpected trailing data")
+			}
+			return nil
+		}(); err != nil {
+			err = &ogenerrors.DecodeBodyError{
+				ContentType: ct,
+				Body:        buf,
+				Err:         err,
+			}
+			return req, close, err
+		}
+		return &request, close, nil
+	default:
+		return req, close, validate.InvalidContentType(ct)
+	}
+}
+
 func (s *Server) decodeUpdateUeRequest(r *http.Request) (
 	req *UpdateUeReq,
 	close func() error,

ent/ogent/oas_request_encoders_gen.go

@@ -53,6 +53,20 @@ func encodeCreateMaRequest(
 	return nil
 }
 
+func encodeCreateSevRequest(
+	req *CreateSevReq,
+	r *http.Request,
+) error {
+	const contentType = "application/json"
+	e := jx.GetEncoder()
+	{
+		req.Encode(e)
+	}
+	encoded := e.Bytes()
+	ht.SetBody(r, bytes.NewReader(encoded), contentType)
+	return nil
+}
+
 func encodeCreateUeRequest(
 	req *CreateUeReq,
 	r *http.Request,
@@ -123,6 +137,20 @@ func encodeUpdateMaRequest(
 	return nil
 }
 
+func encodeUpdateSevRequest(
+	req *UpdateSevReq,
+	r *http.Request,
+) error {
+	const contentType = "application/json"
+	e := jx.GetEncoder()
+	{
+		req.Encode(e)
+	}
+	encoded := e.Bytes()
+	ht.SetBody(r, bytes.NewReader(encoded), contentType)
+	return nil
+}
+
 func encodeUpdateUeRequest(
 	req *UpdateUeReq,
 	r *http.Request,

ent/ogent/oas_response_encoders_gen.go

@@ -176,6 +176,61 @@ func encodeCreateMaResponse(response CreateMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeCreateSevResponse(response CreateSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *SevCreate:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeCreateUeResponse(response CreateUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeCreate:
@@ -469,6 +524,67 @@ func encodeDeleteMaResponse(response DeleteMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeDeleteSevResponse(response DeleteSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *DeleteSevNoContent:
+		w.WriteHeader(204)
+		span.SetStatus(codes.Ok, http.StatusText(204))
+
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeDeleteUeResponse(response DeleteUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *DeleteUeNoContent:
@@ -875,6 +991,74 @@ func encodeListMaResponse(response ListMaRes, w http.ResponseWriter, span trace.
 	}
 }
 
+func encodeListSevResponse(response ListSevRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *ListSevOKApplicationJSON:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeListUeResponse(response ListUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *ListUeOKApplicationJSON:
@@ -1146,6 +1330,73 @@ func encodeListUserMaResponse(response ListUserMaRes, w http.ResponseWriter, spa
 	}
 }
 
+func encodeListUserSevResponse(response ListUserSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *ListUserSevOKApplicationJSON:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeListUserUeResponse(response ListUserUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *ListUserUeOKApplicationJSON:
@@ -1485,6 +1736,7 @@ func encodeReadMaResponse(response ReadMaRes, w http.ResponseWriter, span trace.
 }
 
 func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://manga.syui.ai")
 	switch response := response.(type) {
 	case *MaOwnerRead:
 		w.Header().Set("Content-Type", "application/json")
@@ -1551,6 +1803,142 @@ func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, s
 	}
 }
 
+func encodeReadSevResponse(response ReadSevRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *SevRead:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
+func encodeReadSevOwnerResponse(response ReadSevOwnerRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *SevOwnerRead:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeReadUeResponse(response ReadUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeRead:
@@ -1686,6 +2074,7 @@ func encodeReadUeOwnerResponse(response ReadUeOwnerRes, w http.ResponseWriter, s
 }
 
 func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
 	switch response := response.(type) {
 	case *UserRead:
 		w.Header().Set("Content-Type", "application/json")
@@ -1953,6 +2342,73 @@ func encodeUpdateMaResponse(response UpdateMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeUpdateSevResponse(response UpdateSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *SevUpdate:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeUpdateUeResponse(response UpdateUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeUpdate:

ent/ogent/oas_router_gen.go

@@ -318,6 +318,85 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 								s.notAllowed(w, r, "GET")
 							}
 
+							return
+						}
+					}
+				}
+			case 's': // Prefix: "sevs"
+				if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" {
+					elem = elem[l:]
+				} else {
+					break
+				}
+
+				if len(elem) == 0 {
+					switch r.Method {
+					case "GET":
+						s.handleListSevRequest([0]string{}, w, r)
+					case "POST":
+						s.handleCreateSevRequest([0]string{}, w, r)
+					default:
+						s.notAllowed(w, r, "GET,POST")
+					}
+
+					return
+				}
+				switch elem[0] {
+				case '/': // Prefix: "/"
+					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
+						elem = elem[l:]
+					} else {
+						break
+					}
+
+					// Param: "id"
+					// Match until "/"
+					idx := strings.IndexByte(elem, '/')
+					if idx < 0 {
+						idx = len(elem)
+					}
+					args[0] = elem[:idx]
+					elem = elem[idx:]
+
+					if len(elem) == 0 {
+						switch r.Method {
+						case "DELETE":
+							s.handleDeleteSevRequest([1]string{
+								args[0],
+							}, w, r)
+						case "GET":
+							s.handleReadSevRequest([1]string{
+								args[0],
+							}, w, r)
+						case "PATCH":
+							s.handleUpdateSevRequest([1]string{
+								args[0],
+							}, w, r)
+						default:
+							s.notAllowed(w, r, "DELETE,GET,PATCH")
+						}
+
+						return
+					}
+					switch elem[0] {
+					case '/': // Prefix: "/owner"
+						if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
+							elem = elem[l:]
+						} else {
+							break
+						}
+
+						if len(elem) == 0 {
+							// Leaf node.
+							switch r.Method {
+							case "GET":
+								s.handleReadSevOwnerRequest([1]string{
+									args[0],
+								}, w, r)
+							default:
+								s.notAllowed(w, r, "GET")
+							}
+
 							return
 						}
 					}
@@ -539,6 +618,26 @@ func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
 										s.notAllowed(w, r, "GET")
 									}
 
+									return
+								}
+							case 's': // Prefix: "sev"
+								if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" {
+									elem = elem[l:]
+								} else {
+									break
+								}
+
+								if len(elem) == 0 {
+									// Leaf node.
+									switch r.Method {
+									case "GET":
+										s.handleListUserSevRequest([1]string{
+											args[0],
+										}, w, r)
+									default:
+										s.notAllowed(w, r, "GET")
+									}
+
 									return
 								}
 							case 'u': // Prefix: "ue"
@@ -964,6 +1063,101 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
 						}
 					}
 				}
+			case 's': // Prefix: "sevs"
+				if l := len("sevs"); len(elem) >= l && elem[0:l] == "sevs" {
+					elem = elem[l:]
+				} else {
+					break
+				}
+
+				if len(elem) == 0 {
+					switch method {
+					case "GET":
+						r.name = "ListSev"
+						r.operationID = "listSev"
+						r.pathPattern = "/sevs"
+						r.args = args
+						r.count = 0
+						return r, true
+					case "POST":
+						r.name = "CreateSev"
+						r.operationID = "createSev"
+						r.pathPattern = "/sevs"
+						r.args = args
+						r.count = 0
+						return r, true
+					default:
+						return
+					}
+				}
+				switch elem[0] {
+				case '/': // Prefix: "/"
+					if l := len("/"); len(elem) >= l && elem[0:l] == "/" {
+						elem = elem[l:]
+					} else {
+						break
+					}
+
+					// Param: "id"
+					// Match until "/"
+					idx := strings.IndexByte(elem, '/')
+					if idx < 0 {
+						idx = len(elem)
+					}
+					args[0] = elem[:idx]
+					elem = elem[idx:]
+
+					if len(elem) == 0 {
+						switch method {
+						case "DELETE":
+							r.name = "DeleteSev"
+							r.operationID = "deleteSev"
+							r.pathPattern = "/sevs/{id}"
+							r.args = args
+							r.count = 1
+							return r, true
+						case "GET":
+							r.name = "ReadSev"
+							r.operationID = "readSev"
+							r.pathPattern = "/sevs/{id}"
+							r.args = args
+							r.count = 1
+							return r, true
+						case "PATCH":
+							r.name = "UpdateSev"
+							r.operationID = "updateSev"
+							r.pathPattern = "/sevs/{id}"
+							r.args = args
+							r.count = 1
+							return r, true
+						default:
+							return
+						}
+					}
+					switch elem[0] {
+					case '/': // Prefix: "/owner"
+						if l := len("/owner"); len(elem) >= l && elem[0:l] == "/owner" {
+							elem = elem[l:]
+						} else {
+							break
+						}
+
+						if len(elem) == 0 {
+							switch method {
+							case "GET":
+								// Leaf: ReadSevOwner
+								r.name = "ReadSevOwner"
+								r.operationID = "readSevOwner"
+								r.pathPattern = "/sevs/{id}/owner"
+								r.args = args
+								r.count = 1
+								return r, true
+							default:
+								return
+							}
+						}
+					}
+				}
 			case 'u': // Prefix: "u"
 				if l := len("u"); len(elem) >= l && elem[0:l] == "u" {
 					elem = elem[l:]
@@ -1217,6 +1411,27 @@ func (s *Server) FindPath(method string, u *url.URL) (r Route, _ bool) {
 										return
 									}
 								}
+							case 's': // Prefix: "sev"
+								if l := len("sev"); len(elem) >= l && elem[0:l] == "sev" {
+									elem = elem[l:]
+								} else {
+									break
+								}
+
+								if len(elem) == 0 {
+									switch method {
+									case "GET":
+										// Leaf: ListUserSev
+										r.name = "ListUserSev"
+										r.operationID = "listUserSev"
+										r.pathPattern = "/users/{id}/sev"
+										r.args = args
+										r.count = 1
+										return r, true
+									default:
+										return
+									}
+								}
 							case 'u': // Prefix: "ue"
 								if l := len("ue"); len(elem) >= l && elem[0:l] == "ue" {
 									elem = elem[l:]

ent/ogent/oas_server_gen.go

@@ -26,6 +26,12 @@ type Handler interface {
 	//
 	// POST /mas
 	CreateMa(ctx context.Context, req *CreateMaReq) (CreateMaRes, error)
+	// CreateSev implements createSev operation.
+	//
+	// Creates a new Sev and persists it to storage.
+	//
+	// POST /sevs
+	CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error)
 	// CreateUe implements createUe operation.
 	//
 	// Creates a new Ue and persists it to storage.
@@ -56,6 +62,12 @@ type Handler interface {
 	//
 	// DELETE /mas/{id}
 	DeleteMa(ctx context.Context, params DeleteMaParams) (DeleteMaRes, error)
+	// DeleteSev implements deleteSev operation.
+	//
+	// Deletes the Sev with the requested ID.
+	//
+	// DELETE /sevs/{id}
+	DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error)
 	// DeleteUe implements deleteUe operation.
 	//
 	// Deletes the Ue with the requested ID.
@@ -104,6 +116,12 @@ type Handler interface {
 	//
 	// GET /mas
 	ListMa(ctx context.Context, params ListMaParams) (ListMaRes, error)
+	// ListSev implements listSev operation.
+	//
+	// List Sevs.
+	//
+	// GET /sevs
+	ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error)
 	// ListUe implements listUe operation.
 	//
 	// List Ues.
@@ -128,6 +146,12 @@ type Handler interface {
 	//
 	// GET /users/{id}/ma
 	ListUserMa(ctx context.Context, params ListUserMaParams) (ListUserMaRes, error)
+	// ListUserSev implements listUserSev operation.
+	//
+	// List attached Sevs.
+	//
+	// GET /users/{id}/sev
+	ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error)
 	// ListUserUe implements listUserUe operation.
 	//
 	// List attached Ues.
@@ -164,6 +188,18 @@ type Handler interface {
 	//
 	// GET /mas/{id}/owner
 	ReadMaOwner(ctx context.Context, params ReadMaOwnerParams) (ReadMaOwnerRes, error)
+	// ReadSev implements readSev operation.
+	//
+	// Finds the Sev with the requested ID and returns it.
+	//
+	// GET /sevs/{id}
+	ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error)
+	// ReadSevOwner implements readSevOwner operation.
+	//
+	// Find the attached User of the Sev with the given ID.
+	//
+	// GET /sevs/{id}/owner
+	ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error)
 	// ReadUe implements readUe operation.
 	//
 	// Finds the Ue with the requested ID and returns it.
@@ -200,6 +236,12 @@ type Handler interface {
 	//
 	// PATCH /mas/{id}
 	UpdateMa(ctx context.Context, req *UpdateMaReq, params UpdateMaParams) (UpdateMaRes, error)
+	// UpdateSev implements updateSev operation.
+	//
+	// Updates a Sev and persists changes to storage.
+	//
+	// PATCH /sevs/{id}
+	UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error)
 	// UpdateUe implements updateUe operation.
 	//
 	// Updates a Ue and persists changes to storage.

ent/ogent/oas_unimplemented_gen.go

@@ -40,6 +40,15 @@ func (UnimplementedHandler) CreateMa(ctx context.Context, req *CreateMaReq) (r C
 	return r, ht.ErrNotImplemented
 }
 
+// CreateSev implements createSev operation.
+//
+// Creates a new Sev and persists it to storage.
+//
+// POST /sevs
+func (UnimplementedHandler) CreateSev(ctx context.Context, req *CreateSevReq) (r CreateSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // CreateUe implements createUe operation.
 //
 // Creates a new Ue and persists it to storage.
@@ -85,6 +94,15 @@ func (UnimplementedHandler) DeleteMa(ctx context.Context, params DeleteMaParams)
 	return r, ht.ErrNotImplemented
 }
 
+// DeleteSev implements deleteSev operation.
+//
+// Deletes the Sev with the requested ID.
+//
+// DELETE /sevs/{id}
+func (UnimplementedHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (r DeleteSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // DeleteUe implements deleteUe operation.
 //
 // Deletes the Ue with the requested ID.
@@ -157,6 +175,15 @@ func (UnimplementedHandler) ListMa(ctx context.Context, params ListMaParams) (r
 	return r, ht.ErrNotImplemented
 }
 
+// ListSev implements listSev operation.
+//
+// List Sevs.
+//
+// GET /sevs
+func (UnimplementedHandler) ListSev(ctx context.Context, params ListSevParams) (r ListSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // ListUe implements listUe operation.
 //
 // List Ues.
@@ -193,6 +220,15 @@ func (UnimplementedHandler) ListUserMa(ctx context.Context, params ListUserMaPar
 	return r, ht.ErrNotImplemented
 }
 
+// ListUserSev implements listUserSev operation.
+//
+// List attached Sevs.
+//
+// GET /users/{id}/sev
+func (UnimplementedHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (r ListUserSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // ListUserUe implements listUserUe operation.
 //
 // List attached Ues.
@@ -247,6 +283,24 @@ func (UnimplementedHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerP
 	return r, ht.ErrNotImplemented
 }
 
+// ReadSev implements readSev operation.
+//
+// Finds the Sev with the requested ID and returns it.
+//
+// GET /sevs/{id}
+func (UnimplementedHandler) ReadSev(ctx context.Context, params ReadSevParams) (r ReadSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
+// ReadSevOwner implements readSevOwner operation.
+//
+// Find the attached User of the Sev with the given ID.
+//
+// GET /sevs/{id}/owner
+func (UnimplementedHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (r ReadSevOwnerRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // ReadUe implements readUe operation.
 //
 // Finds the Ue with the requested ID and returns it.
@@ -301,6 +355,15 @@ func (UnimplementedHandler) UpdateMa(ctx context.Context, req *UpdateMaReq, para
 	return r, ht.ErrNotImplemented
 }
 
+// UpdateSev implements updateSev operation.
+//
+// Updates a Sev and persists changes to storage.
+//
+// PATCH /sevs/{id}
+func (UnimplementedHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (r UpdateSevRes, _ error) {
+	return r, ht.ErrNotImplemented
+}
+
 // UpdateUe implements updateUe operation.
 //
 // Updates a Ue and persists changes to storage.

ent/ogent/oas_validators_gen.go

@@ -30,6 +30,12 @@ func (s ListMaOKApplicationJSON) Validate() error {
 	}
 	return nil
 }
+func (s ListSevOKApplicationJSON) Validate() error {
+	if s == nil {
+		return errors.New("nil is invalid value")
+	}
+	return nil
+}
 func (s ListUeOKApplicationJSON) Validate() error {
 	if s == nil {
 		return errors.New("nil is invalid value")
@@ -54,6 +60,12 @@ func (s ListUserOKApplicationJSON) Validate() error {
 	}
 	return nil
 }
+func (s ListUserSevOKApplicationJSON) Validate() error {
+	if s == nil {
+		return errors.New("nil is invalid value")
+	}
+	return nil
+}
 func (s ListUserUeOKApplicationJSON) Validate() error {
 	if s == nil {
 		return errors.New("nil is invalid value")

ent/ogent/ogent.go

@@ -11,6 +11,7 @@ import (
 	"api/ent/group"
 	"api/ent/ma"
 	"api/ent/ue"
+	"api/ent/sev"
 	"api/ent/user"
 
 	"os"
@@ -781,6 +782,276 @@ func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams
 	return NewMaOwnerRead(e), nil
 }
 
+// CreateSev handles POST /sevs requests.
+func (h *OgentHandler) CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) {
+	b := h.client.Sev.Create()
+	// Add all fields.
+	b.SetPassword(req.Password)
+	if v, ok := req.Token.Get(); ok {
+		b.SetToken(v)
+	}
+	if v, ok := req.Limit.Get(); ok {
+		b.SetLimit(v)
+	}
+	if v, ok := req.Count.Get(); ok {
+		b.SetCount(v)
+	}
+	if v, ok := req.Handle.Get(); ok {
+		b.SetHandle(v)
+	}
+	if v, ok := req.Did.Get(); ok {
+		b.SetDid(v)
+	}
+	if v, ok := req.UID.Get(); ok {
+		b.SetUID(v)
+	}
+	if v, ok := req.Cid.Get(); ok {
+		b.SetCid(v)
+	}
+	if v, ok := req.Card.Get(); ok {
+		b.SetCard(v)
+	}
+	if v, ok := req.Cp.Get(); ok {
+		b.SetCp(v)
+	}
+	if v, ok := req.UpdatedAt.Get(); ok {
+		b.SetUpdatedAt(v)
+	}
+	if v, ok := req.CreatedAt.Get(); ok {
+		b.SetCreatedAt(v)
+	}
+
+	// Add all edges.
+	//b.SetOwnerID(req.Owner)
+	if req.Password == password {
+		b.SetOwnerID(req.Owner)
+	} else {
+		b.SetOwnerID(0)
+	}
+	// Persist to storage.
+	e, err := b.Save(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	// Reload the entity to attach all eager-loaded edges.
+	q := h.client.Sev.Query().Where(sev.ID(e.ID))
+	e, err = q.Only(ctx)
+	if err != nil {
+		// This should never happen.
+		return nil, err
+	}
+	return NewSevCreate(e), nil
+}
+
+// ReadSev handles GET /sevs/{id} requests.
+func (h *OgentHandler) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) {
+	q := h.client.Sev.Query().Where(sev.IDEQ(params.ID))
+	e, err := q.Only(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return NewSevRead(e), nil
+}
+
+// UpdateSev handles PATCH /sevs/{id} requests.
+func (h *OgentHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) {
+	b := h.client.Sev.UpdateOneID(params.ID)
+	// Add all fields.
+	if v, ok := req.Token.Get(); ok {
+		b.SetToken(v)
+	}
+	if v, ok := req.Limit.Get(); ok {
+		b.SetLimit(v)
+	}
+	if v, ok := req.Count.Get(); ok {
+		b.SetCount(v)
+	}
+	if v, ok := req.Handle.Get(); ok {
+		b.SetHandle(v)
+	}
+	if v, ok := req.Did.Get(); ok {
+		b.SetDid(v)
+	}
+	if v, ok := req.UID.Get(); ok {
+		b.SetUID(v)
+	}
+	if v, ok := req.Cid.Get(); ok {
+		b.SetCid(v)
+	}
+	if v, ok := req.Card.Get(); ok {
+		b.SetCard(v)
+	}
+	if v, ok := req.Cp.Get(); ok {
+		b.SetCp(v)
+	}
+	if v, ok := req.UpdatedAt.Get(); ok {
+		b.SetUpdatedAt(v)
+	}
+	// Add all edges.
+	//if v, ok := req.Owner.Get(); ok {
+	//	b.SetOwnerID(v)
+	//}
+	if v, ok := req.Token.Get(); ok {
+		if v == token {
+			b.SetToken(v)
+			if v, ok := req.Owner.Get(); ok {
+				b.SetOwnerID(v)
+			}
+		}
+	}
+	// Persist to storage.
+	e, err := b.Save(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	// Reload the entity to attach all eager-loaded edges.
+	q := h.client.Sev.Query().Where(sev.ID(e.ID))
+	e, err = q.Only(ctx)
+	if err != nil {
+		// This should never happen.
+		return nil, err
+	}
+	return NewSevUpdate(e), nil
+}
+
+// DeleteSev handles DELETE /sevs/{id} requests.
+func (h *OgentHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) {
+	//err := h.client.Sev.DeleteOneID(params.ID).Exec(ctx)
+	err := h.client.Sev.DeleteOneID(0).Exec(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return new(DeleteSevNoContent), nil
+
+}
+
+// ListSev handles GET /sevs requests.
+func (h *OgentHandler) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) {
+	q := h.client.Sev.Query()
+	page := 1
+	if v, ok := params.Page.Get(); ok {
+		page = v
+	}
+	itemsPerPage := 30
+	if v, ok := params.ItemsPerPage.Get(); ok {
+		itemsPerPage = v
+	}
+	q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
+
+	es, err := q.All(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	r := NewSevLists(es)
+	return (*ListSevOKApplicationJSON)(&r), nil
+}
+
+// ReadSevOwner handles GET /sevs/{id}/owner requests.
+func (h *OgentHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) {
+	q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)).QueryOwner()
+	e, err := q.Only(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return NewSevOwnerRead(e), nil
+}
+
 // CreateUe handles POST /ues requests.
 func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) {
 	b := h.client.Ue.Create()
@@ -1671,3 +1942,39 @@ func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams)
 	r := NewUserMaLists(es)
 	return (*ListUserMaOKApplicationJSON)(&r), nil
 }
+
+// ListUserSev handles GET /users/{id}/sev requests.
+func (h *OgentHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) {
+	q := h.client.User.Query().Where(user.IDEQ(params.ID)).QuerySev()
+	page := 1
+	if v, ok := params.Page.Get(); ok {
+		page = v
+	}
+	itemsPerPage := 30
+	if v, ok := params.ItemsPerPage.Get(); ok {
+		itemsPerPage = v
+	}
+	q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
+	es, err := q.All(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	r := NewUserSevLists(es)
+	return (*ListUserSevOKApplicationJSON)(&r), nil
+}

ent/ogent/responses.go

@@ -637,6 +637,229 @@ func (u *MaOwnerRead) Elem() MaOwnerRead {
 	return *u
 }
 
+func NewSevCreate(e *ent.Sev) *SevCreate {
+	if e == nil {
+		return nil
+	}
+	var ret SevCreate
+	ret.ID = e.ID
+	ret.Limit = NewOptBool(e.Limit)
+	ret.Count = NewOptInt(e.Count)
+	ret.Handle = NewOptString(e.Handle)
+	ret.Did = NewOptString(e.Did)
+	ret.UID = NewOptInt(e.UID)
+	ret.Cid = NewOptInt(e.Cid)
+	ret.Cp = NewOptInt(e.Cp)
+	ret.Card = NewOptInt(e.Card)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	return &ret
+}
+
+func NewSevCreates(es []*ent.Sev) []SevCreate {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]SevCreate, len(es))
+	for i, e := range es {
+		r[i] = NewSevCreate(e).Elem()
+	}
+	return r
+}
+
+func (s *SevCreate) Elem() SevCreate {
+	if s == nil {
+		return SevCreate{}
+	}
+	return *s
+}
+
+func NewSevList(e *ent.Sev) *SevList {
+	if e == nil {
+		return nil
+	}
+	var ret SevList
+	ret.ID = e.ID
+	ret.Limit = NewOptBool(e.Limit)
+	ret.Count = NewOptInt(e.Count)
+	ret.Handle = NewOptString(e.Handle)
+	ret.Did = NewOptString(e.Did)
+	ret.UID = NewOptInt(e.UID)
+	ret.Cid = NewOptInt(e.Cid)
+	ret.Cp = NewOptInt(e.Cp)
+	ret.Card = NewOptInt(e.Card)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	return &ret
+}
+
+func NewSevLists(es []*ent.Sev) []SevList {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]SevList, len(es))
+	for i, e := range es {
+		r[i] = NewSevList(e).Elem()
+	}
+	return r
+}
+
+func (s *SevList) Elem() SevList {
+	if s == nil {
+		return SevList{}
+	}
+	return *s
+}
+
+func NewSevRead(e *ent.Sev) *SevRead {
+	if e == nil {
+		return nil
+	}
+	var ret SevRead
+	ret.ID = e.ID
+	ret.Limit = NewOptBool(e.Limit)
+	ret.Count = NewOptInt(e.Count)
+	ret.Handle = NewOptString(e.Handle)
+	ret.Did = NewOptString(e.Did)
+	ret.UID = NewOptInt(e.UID)
+	ret.Cid = NewOptInt(e.Cid)
+	ret.Cp = NewOptInt(e.Cp)
+	ret.Card = NewOptInt(e.Card)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	return &ret
+}
+
+func NewSevReads(es []*ent.Sev) []SevRead {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]SevRead, len(es))
+	for i, e := range es {
+		r[i] = NewSevRead(e).Elem()
+	}
+	return r
+}
+
+func (s *SevRead) Elem() SevRead {
+	if s == nil {
+		return SevRead{}
+	}
+	return *s
+}
+
+func NewSevUpdate(e *ent.Sev) *SevUpdate {
+	if e == nil {
+		return nil
+	}
+	var ret SevUpdate
+	ret.ID = e.ID
+	ret.Limit = NewOptBool(e.Limit)
+	ret.Count = NewOptInt(e.Count)
+	ret.Handle = NewOptString(e.Handle)
+	ret.Did = NewOptString(e.Did)
+	ret.UID = NewOptInt(e.UID)
+	ret.Cid = NewOptInt(e.Cid)
+	ret.Cp = NewOptInt(e.Cp)
+	ret.Card = NewOptInt(e.Card)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	return &ret
+}
+
+func NewSevUpdates(es []*ent.Sev) []SevUpdate {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]SevUpdate, len(es))
+	for i, e := range es {
+		r[i] = NewSevUpdate(e).Elem()
+	}
+	return r
+}
+
+func (s *SevUpdate) Elem() SevUpdate {
+	if s == nil {
+		return SevUpdate{}
+	}
+	return *s
+}
+
+func NewSevOwnerRead(e *ent.User) *SevOwnerRead {
+	if e == nil {
+		return nil
+	}
+	var ret SevOwnerRead
+	ret.ID = e.ID
+	ret.Username = e.Username
+	ret.Did = NewOptString(e.Did)
+	ret.Member = NewOptBool(e.Member)
+	ret.Book = NewOptBool(e.Book)
+	ret.Manga = NewOptBool(e.Manga)
+	ret.Badge = NewOptBool(e.Badge)
+	ret.Bsky = NewOptBool(e.Bsky)
+	ret.Mastodon = NewOptBool(e.Mastodon)
+	ret.Delete = NewOptBool(e.Delete)
+	ret.Handle = NewOptBool(e.Handle)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.RaidAt = NewOptDateTime(e.RaidAt)
+	ret.ServerAt = NewOptDateTime(e.ServerAt)
+	ret.EggAt = NewOptDateTime(e.EggAt)
+	ret.Luck = NewOptInt(e.Luck)
+	ret.LuckAt = NewOptDateTime(e.LuckAt)
+	ret.Like = NewOptInt(e.Like)
+	ret.LikeRank = NewOptInt(e.LikeRank)
+	ret.LikeAt = NewOptDateTime(e.LikeAt)
+	ret.Fav = NewOptInt(e.Fav)
+	ret.Ten = NewOptBool(e.Ten)
+	ret.TenSu = NewOptInt(e.TenSu)
+	ret.TenKai = NewOptInt(e.TenKai)
+	ret.Aiten = NewOptInt(e.Aiten)
+	ret.TenCard = NewOptString(e.TenCard)
+	ret.TenDelete = NewOptString(e.TenDelete)
+	ret.TenPost = NewOptString(e.TenPost)
+	ret.TenGet = NewOptString(e.TenGet)
+	ret.TenAt = NewOptDateTime(e.TenAt)
+	ret.Next = NewOptString(e.Next)
+	ret.Room = NewOptInt(e.Room)
+	ret.Model = NewOptBool(e.Model)
+	ret.ModelAt = NewOptDateTime(e.ModelAt)
+	ret.ModelAttack = NewOptInt(e.ModelAttack)
+	ret.ModelLimit = NewOptInt(e.ModelLimit)
+	ret.ModelSkill = NewOptInt(e.ModelSkill)
+	ret.ModelMode = NewOptInt(e.ModelMode)
+	ret.ModelCritical = NewOptInt(e.ModelCritical)
+	ret.ModelCriticalD = NewOptInt(e.ModelCriticalD)
+	ret.Game = NewOptBool(e.Game)
+	ret.GameTest = NewOptBool(e.GameTest)
+	ret.GameEnd = NewOptBool(e.GameEnd)
+	ret.GameAccount = NewOptBool(e.GameAccount)
+	ret.GameLv = NewOptInt(e.GameLv)
+	ret.Coin = NewOptInt(e.Coin)
+	ret.CoinOpen = NewOptBool(e.CoinOpen)
+	ret.CoinAt = NewOptDateTime(e.CoinAt)
+	return &ret
+}
+
+func NewSevOwnerReads(es []*ent.User) []SevOwnerRead {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]SevOwnerRead, len(es))
+	for i, e := range es {
+		r[i] = NewSevOwnerRead(e).Elem()
+	}
+	return r
+}
+
+func (u *SevOwnerRead) Elem() SevOwnerRead {
+	if u == nil {
+		return SevOwnerRead{}
+	}
+	return *u
+}
+
 func NewUeCreate(e *ent.Ue) *UeCreate {
 	if e == nil {
 		return nil
@@ -1262,6 +1485,43 @@ func (m *UserMaList) Elem() UserMaList {
 	return *m
 }
 
+func NewUserSevList(e *ent.Sev) *UserSevList {
+	if e == nil {
+		return nil
+	}
+	var ret UserSevList
+	ret.ID = e.ID
+	ret.Limit = NewOptBool(e.Limit)
+	ret.Count = NewOptInt(e.Count)
+	ret.Handle = NewOptString(e.Handle)
+	ret.Did = NewOptString(e.Did)
+	ret.UID = NewOptInt(e.UID)
+	ret.Cid = NewOptInt(e.Cid)
+	ret.Cp = NewOptInt(e.Cp)
+	ret.Card = NewOptInt(e.Card)
+	ret.UpdatedAt = NewOptDateTime(e.UpdatedAt)
+	ret.CreatedAt = NewOptDateTime(e.CreatedAt)
+	return &ret
+}
+
+func NewUserSevLists(es []*ent.Sev) []UserSevList {
+	if len(es) == 0 {
+		return nil
+	}
+	r := make([]UserSevList, len(es))
+	for i, e := range es {
+		r[i] = NewUserSevList(e).Elem()
+	}
+	return r
+}
+
+func (s *UserSevList) Elem() UserSevList {
+	if s == nil {
+		return UserSevList{}
+	}
+	return *s
+}
+
 func NewUserUeList(e *ent.Ue) *UserUeList {
 	if e == nil {
 		return nil

ent/openapi.json

@@ -1077,6 +1077,367 @@
         }
       }
     },
+    "/sevs": {
+      "get": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "List Sevs",
+        "description": "List Sevs.",
+        "operationId": "listSev",
+        "parameters": [
+          {
+            "name": "page",
+            "in": "query",
+            "description": "what page to render",
+            "schema": {
+              "type": "integer",
+              "minimum": 1
+            }
+          },
+          {
+            "name": "itemsPerPage",
+            "in": "query",
+            "description": "item count to render per page",
+            "schema": {
+              "type": "integer",
+              "maximum": 5000,
+              "minimum": 1
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "result Sev list",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/SevList"
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      },
+      "post": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "Create a new Sev",
+        "description": "Creates a new Sev and persists it to storage.",
+        "operationId": "createSev",
+        "requestBody": {
+          "description": "Sev to create",
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "password": {
+                    "type": "string"
+                  },
+                  "token": {
+                    "type": "string"
+                  },
+                  "limit": {
+                    "type": "boolean"
+                  },
+                  "count": {
+                    "type": "integer"
+                  },
+                  "handle": {
+                    "type": "string"
+                  },
+                  "did": {
+                    "type": "string"
+                  },
+                  "uid": {
+                    "type": "integer"
+                  },
+                  "cid": {
+                    "type": "integer"
+                  },
+                  "cp": {
+                    "type": "integer"
+                  },
+                  "card": {
+                    "type": "integer"
+                  },
+                  "updated_at": {
+                    "type": "string",
+                    "format": "date-time"
+                  },
+                  "created_at": {
+                    "type": "string",
+                    "format": "date-time"
+                  },
+                  "owner": {
+                    "type": "integer"
+                  }
+                },
+                "required": [
+                  "password",
+                  "owner"
+                ]
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Sev created",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SevCreate"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      }
+    },
+    "/sevs/{id}": {
+      "get": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "Find a Sev by ID",
+        "description": "Finds the Sev with the requested ID and returns it.",
+        "operationId": "readSev",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "ID of the Sev",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "Sev with requested ID was found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SevRead"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      },
+      "delete": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "Deletes a Sev by ID",
+        "description": "Deletes the Sev with the requested ID.",
+        "operationId": "deleteSev",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "ID of the Sev",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "204": {
+            "description": "Sev with requested ID was deleted"
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      },
+      "patch": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "Updates a Sev",
+        "description": "Updates a Sev and persists changes to storage.",
+        "operationId": "updateSev",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "ID of the Sev",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "requestBody": {
+          "description": "Sev properties to update",
+          "content": {
+            "application/json": {
+              "schema": {
+                "type": "object",
+                "properties": {
+                  "token": {
+                    "type": "string"
+                  },
+                  "limit": {
+                    "type": "boolean"
+                  },
+                  "count": {
+                    "type": "integer"
+                  },
+                  "handle": {
+                    "type": "string"
+                  },
+                  "did": {
+                    "type": "string"
+                  },
+                  "uid": {
+                    "type": "integer"
+                  },
+                  "cid": {
+                    "type": "integer"
+                  },
+                  "cp": {
+                    "type": "integer"
+                  },
+                  "card": {
+                    "type": "integer"
+                  },
+                  "updated_at": {
+                    "type": "string",
+                    "format": "date-time"
+                  },
+                  "owner": {
+                    "type": "integer"
+                  }
+                }
+              }
+            }
+          },
+          "required": true
+        },
+        "responses": {
+          "200": {
+            "description": "Sev updated",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/SevUpdate"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      }
+    },
+    "/sevs/{id}/owner": {
+      "get": {
+        "tags": [
+          "Sev"
+        ],
+        "summary": "Find the attached User",
+        "description": "Find the attached User of the Sev with the given ID",
+        "operationId": "readSevOwner",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "ID of the Sev",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "User attached to Sev with requested ID was found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/Sev_OwnerRead"
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      }
+    },
     "/ues": {
       "get": {
         "tags": [
@@ -1726,6 +2087,12 @@
                     "items": {
                       "type": "integer"
                     }
+                  },
+                  "sev": {
+                    "type": "array",
+                    "items": {
+                      "type": "integer"
+                    }
                   }
                 },
                 "required": [
@@ -2032,6 +2399,12 @@
                     "items": {
                       "type": "integer"
                     }
+                  },
+                  "sev": {
+                    "type": "array",
+                    "items": {
+                      "type": "integer"
+                    }
                   }
                 }
               }
@@ -2218,6 +2591,70 @@
         }
       }
     },
+    "/users/{id}/sev": {
+      "get": {
+        "tags": [
+          "User"
+        ],
+        "summary": "List attached Sevs",
+        "description": "List attached Sevs.",
+        "operationId": "listUserSev",
+        "parameters": [
+          {
+            "name": "id",
+            "in": "path",
+            "description": "ID of the User",
+            "required": true,
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "name": "page",
+            "in": "query",
+            "description": "what page to render",
+            "schema": {
+              "type": "integer"
+            }
+          },
+          {
+            "name": "itemsPerPage",
+            "in": "query",
+            "description": "item count to render per page",
+            "schema": {
+              "type": "integer"
+            }
+          }
+        ],
+        "responses": {
+          "200": {
+            "description": "result Users list",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/components/schemas/User_SevList"
+                  }
+                }
+              }
+            }
+          },
+          "400": {
+            "$ref": "#/components/responses/400"
+          },
+          "404": {
+            "$ref": "#/components/responses/404"
+          },
+          "409": {
+            "$ref": "#/components/responses/409"
+          },
+          "500": {
+            "$ref": "#/components/responses/500"
+          }
+        }
+      }
+    },
     "/users/{id}/ue": {
       "get": {
         "tags": [
@@ -3315,6 +3752,398 @@
           "username"
         ]
       },
+      "Sev": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "password": {
+            "type": "string"
+          },
+          "token": {
+            "type": "string"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "owner": {
+            "$ref": "#/components/schemas/User"
+          }
+        },
+        "required": [
+          "id",
+          "password",
+          "owner"
+        ]
+      },
+      "SevCreate": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id"
+        ]
+      },
+      "SevList": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id"
+        ]
+      },
+      "SevRead": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id"
+        ]
+      },
+      "SevUpdate": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id"
+        ]
+      },
+      "Sev_OwnerRead": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "username": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "member": {
+            "type": "boolean"
+          },
+          "book": {
+            "type": "boolean"
+          },
+          "manga": {
+            "type": "boolean"
+          },
+          "badge": {
+            "type": "boolean"
+          },
+          "bsky": {
+            "type": "boolean"
+          },
+          "mastodon": {
+            "type": "boolean"
+          },
+          "delete": {
+            "type": "boolean"
+          },
+          "handle": {
+            "type": "boolean"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "raid_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "server_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "egg_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "luck": {
+            "type": "integer"
+          },
+          "luck_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "like": {
+            "type": "integer"
+          },
+          "like_rank": {
+            "type": "integer"
+          },
+          "like_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "fav": {
+            "type": "integer"
+          },
+          "ten": {
+            "type": "boolean"
+          },
+          "ten_su": {
+            "type": "integer"
+          },
+          "ten_kai": {
+            "type": "integer"
+          },
+          "aiten": {
+            "type": "integer"
+          },
+          "ten_card": {
+            "type": "string"
+          },
+          "ten_delete": {
+            "type": "string"
+          },
+          "ten_post": {
+            "type": "string"
+          },
+          "ten_get": {
+            "type": "string"
+          },
+          "ten_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "next": {
+            "type": "string"
+          },
+          "room": {
+            "type": "integer"
+          },
+          "model": {
+            "type": "boolean"
+          },
+          "model_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "model_attack": {
+            "type": "integer"
+          },
+          "model_limit": {
+            "type": "integer"
+          },
+          "model_skill": {
+            "type": "integer"
+          },
+          "model_mode": {
+            "type": "integer"
+          },
+          "model_critical": {
+            "type": "integer"
+          },
+          "model_critical_d": {
+            "type": "integer"
+          },
+          "game": {
+            "type": "boolean"
+          },
+          "game_test": {
+            "type": "boolean"
+          },
+          "game_end": {
+            "type": "boolean"
+          },
+          "game_account": {
+            "type": "boolean"
+          },
+          "game_lv": {
+            "type": "integer"
+          },
+          "coin": {
+            "type": "integer"
+          },
+          "coin_open": {
+            "type": "boolean"
+          },
+          "coin_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id",
+          "username"
+        ]
+      },
       "Ue": {
         "type": "object",
         "properties": {
@@ -3990,6 +4819,12 @@
             "items": {
               "$ref": "#/components/schemas/Ma"
             }
+          },
+          "sev": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Sev"
+            }
           }
         },
         "required": [
@@ -4747,6 +5582,49 @@
           "id"
         ]
       },
+      "User_SevList": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": "integer"
+          },
+          "limit": {
+            "type": "boolean"
+          },
+          "count": {
+            "type": "integer"
+          },
+          "handle": {
+            "type": "string"
+          },
+          "did": {
+            "type": "string"
+          },
+          "uid": {
+            "type": "integer"
+          },
+          "cid": {
+            "type": "integer"
+          },
+          "cp": {
+            "type": "integer"
+          },
+          "card": {
+            "type": "integer"
+          },
+          "updated_at": {
+            "type": "string",
+            "format": "date-time"
+          },
+          "created_at": {
+            "type": "string",
+            "format": "date-time"
+          }
+        },
+        "required": [
+          "id"
+        ]
+      },
       "User_UeList": {
         "type": "object",
         "properties": {

ent/predicate/predicate.go

@@ -15,6 +15,9 @@ type Group func(*sql.Selector)
 // Ma is the predicate function for ma builders.
 type Ma func(*sql.Selector)
 
+// Sev is the predicate function for sev builders.
+type Sev func(*sql.Selector)
+
 // Ue is the predicate function for ue builders.
 type Ue func(*sql.Selector)
 

ent/runtime.go

@@ -7,6 +7,7 @@ import (
 	"api/ent/group"
 	"api/ent/ma"
 	"api/ent/schema"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 	"time"
@@ -66,6 +67,20 @@ func init() {
 	maDescCreatedAt := maFields[13].Descriptor()
 	// ma.DefaultCreatedAt holds the default value on creation for the created_at field.
 	ma.DefaultCreatedAt = maDescCreatedAt.Default.(func() time.Time)
+	sevFields := schema.Sev{}.Fields()
+	_ = sevFields
+	// sevDescPassword is the schema descriptor for password field.
+	sevDescPassword := sevFields[0].Descriptor()
+	// sev.PasswordValidator is a validator for the "password" field. It is called by the builders before save.
+	sev.PasswordValidator = sevDescPassword.Validators[0].(func(string) error)
+	// sevDescLimit is the schema descriptor for limit field.
+	sevDescLimit := sevFields[2].Descriptor()
+	// sev.DefaultLimit holds the default value on creation for the limit field.
+	sev.DefaultLimit = sevDescLimit.Default.(bool)
+	// sevDescCreatedAt is the schema descriptor for created_at field.
+	sevDescCreatedAt := sevFields[11].Descriptor()
+	// sev.DefaultCreatedAt holds the default value on creation for the created_at field.
+	sev.DefaultCreatedAt = sevDescCreatedAt.Default.(func() time.Time)
 	ueFields := schema.Ue{}.Fields()
 	_ = ueFields
 	// ueDescLimit is the schema descriptor for limit field.

ent/schema/seven.go

@@ -0,0 +1,71 @@
+package schema
+
+import (
+	"time"
+	"entgo.io/ent"
+	"entgo.io/ent/schema/edge"
+	"entgo.io/ent/schema/field"
+)
+
+// Game holds the schema definition for the Game entity.
+type Sev struct {
+	ent.Schema
+}
+
+func (Sev) Fields() []ent.Field {
+	return []ent.Field{  
+
+		field.String("password").
+		NotEmpty().
+		Immutable().
+		Sensitive(),
+
+		field.String("token").
+		Optional().
+		Sensitive(),
+
+		field.Bool("limit").
+		Default(false).
+		Optional(),
+
+		field.Int("count").
+		Optional(),
+
+		field.String("handle").
+		Optional(),
+
+		field.String("did").
+		Optional(),
+
+		field.Int("uid").
+		Optional(),
+
+		field.Int("cid").
+		Optional(),
+
+		field.Int("cp").
+		Optional(),
+
+		field.Int("card").
+		Optional(),
+
+		field.Time("updated_at").
+		Optional(),
+
+		field.Time("created_at").
+		Immutable().
+		Optional().
+		Default(func() time.Time {
+			return time.Now().In(jst)
+		}),
+	}  
+}
+
+func (Sev) Edges() []ent.Edge {
+	return []ent.Edge{
+		edge.From("owner", User.Type).
+			Ref("sev").
+			Unique().
+			Required(),
+	}
+}

ent/schema/user.go

@@ -246,6 +246,7 @@ func (User) Edges() []ent.Edge {
 		edge.To("card", Card.Type),
 		edge.To("ue", Ue.Type),
 		edge.To("ma", Ma.Type),
+		edge.To("sev", Sev.Type),
 			//Unique(),
 	}
 }

ent/sev.go

@@ -0,0 +1,268 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"api/ent/sev"
+	"api/ent/user"
+	"fmt"
+	"strings"
+	"time"
+
+	"entgo.io/ent"
+	"entgo.io/ent/dialect/sql"
+)
+
+// Sev is the model entity for the Sev schema.
+type Sev struct {
+	config `json:"-"`
+	// ID of the ent.
+	ID int `json:"id,omitempty"`
+	// Password holds the value of the "password" field.
+	Password string `json:"-"`
+	// Token holds the value of the "token" field.
+	Token string `json:"-"`
+	// Limit holds the value of the "limit" field.
+	Limit bool `json:"limit,omitempty"`
+	// Count holds the value of the "count" field.
+	Count int `json:"count,omitempty"`
+	// Handle holds the value of the "handle" field.
+	Handle string `json:"handle,omitempty"`
+	// Did holds the value of the "did" field.
+	Did string `json:"did,omitempty"`
+	// UID holds the value of the "uid" field.
+	UID int `json:"uid,omitempty"`
+	// Cid holds the value of the "cid" field.
+	Cid int `json:"cid,omitempty"`
+	// Cp holds the value of the "cp" field.
+	Cp int `json:"cp,omitempty"`
+	// Card holds the value of the "card" field.
+	Card int `json:"card,omitempty"`
+	// UpdatedAt holds the value of the "updated_at" field.
+	UpdatedAt time.Time `json:"updated_at,omitempty"`
+	// CreatedAt holds the value of the "created_at" field.
+	CreatedAt time.Time `json:"created_at,omitempty"`
+	// Edges holds the relations/edges for other nodes in the graph.
+	// The values are being populated by the SevQuery when eager-loading is set.
+	Edges        SevEdges `json:"edges"`
+	user_sev     *int
+	selectValues sql.SelectValues
+}
+
+// SevEdges holds the relations/edges for other nodes in the graph.
+type SevEdges struct {
+	// Owner holds the value of the owner edge.
+	Owner *User `json:"owner,omitempty"`
+	// loadedTypes holds the information for reporting if a
+	// type was loaded (or requested) in eager-loading or not.
+	loadedTypes [1]bool
+}
+
+// OwnerOrErr returns the Owner value or an error if the edge
+// was not loaded in eager-loading, or loaded but was not found.
+func (e SevEdges) OwnerOrErr() (*User, error) {
+	if e.loadedTypes[0] {
+		if e.Owner == nil {
+			// Edge was loaded but was not found.
+			return nil, &NotFoundError{label: user.Label}
+		}
+		return e.Owner, nil
+	}
+	return nil, &NotLoadedError{edge: "owner"}
+}
+
+// scanValues returns the types for scanning values from sql.Rows.
+func (*Sev) scanValues(columns []string) ([]any, error) {
+	values := make([]any, len(columns))
+	for i := range columns {
+		switch columns[i] {
+		case sev.FieldLimit:
+			values[i] = new(sql.NullBool)
+		case sev.FieldID, sev.FieldCount, sev.FieldUID, sev.FieldCid, sev.FieldCp, sev.FieldCard:
+			values[i] = new(sql.NullInt64)
+		case sev.FieldPassword, sev.FieldToken, sev.FieldHandle, sev.FieldDid:
+			values[i] = new(sql.NullString)
+		case sev.FieldUpdatedAt, sev.FieldCreatedAt:
+			values[i] = new(sql.NullTime)
+		case sev.ForeignKeys[0]: // user_sev
+			values[i] = new(sql.NullInt64)
+		default:
+			values[i] = new(sql.UnknownType)
+		}
+	}
+	return values, nil
+}
+
+// assignValues assigns the values that were returned from sql.Rows (after scanning)
+// to the Sev fields.
+func (s *Sev) assignValues(columns []string, values []any) error {
+	if m, n := len(values), len(columns); m < n {
+		return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
+	}
+	for i := range columns {
+		switch columns[i] {
+		case sev.FieldID:
+			value, ok := values[i].(*sql.NullInt64)
+			if !ok {
+				return fmt.Errorf("unexpected type %T for field id", value)
+			}
+			s.ID = int(value.Int64)
+		case sev.FieldPassword:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field password", values[i])
+			} else if value.Valid {
+				s.Password = value.String
+			}
+		case sev.FieldToken:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field token", values[i])
+			} else if value.Valid {
+				s.Token = value.String
+			}
+		case sev.FieldLimit:
+			if value, ok := values[i].(*sql.NullBool); !ok {
+				return fmt.Errorf("unexpected type %T for field limit", values[i])
+			} else if value.Valid {
+				s.Limit = value.Bool
+			}
+		case sev.FieldCount:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field count", values[i])
+			} else if value.Valid {
+				s.Count = int(value.Int64)
+			}
+		case sev.FieldHandle:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field handle", values[i])
+			} else if value.Valid {
+				s.Handle = value.String
+			}
+		case sev.FieldDid:
+			if value, ok := values[i].(*sql.NullString); !ok {
+				return fmt.Errorf("unexpected type %T for field did", values[i])
+			} else if value.Valid {
+				s.Did = value.String
+			}
+		case sev.FieldUID:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field uid", values[i])
+			} else if value.Valid {
+				s.UID = int(value.Int64)
+			}
+		case sev.FieldCid:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field cid", values[i])
+			} else if value.Valid {
+				s.Cid = int(value.Int64)
+			}
+		case sev.FieldCp:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field cp", values[i])
+			} else if value.Valid {
+				s.Cp = int(value.Int64)
+			}
+		case sev.FieldCard:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for field card", values[i])
+			} else if value.Valid {
+				s.Card = int(value.Int64)
+			}
+		case sev.FieldUpdatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field updated_at", values[i])
+			} else if value.Valid {
+				s.UpdatedAt = value.Time
+			}
+		case sev.FieldCreatedAt:
+			if value, ok := values[i].(*sql.NullTime); !ok {
+				return fmt.Errorf("unexpected type %T for field created_at", values[i])
+			} else if value.Valid {
+				s.CreatedAt = value.Time
+			}
+		case sev.ForeignKeys[0]:
+			if value, ok := values[i].(*sql.NullInt64); !ok {
+				return fmt.Errorf("unexpected type %T for edge-field user_sev", value)
+			} else if value.Valid {
+				s.user_sev = new(int)
+				*s.user_sev = int(value.Int64)
+			}
+		default:
+			s.selectValues.Set(columns[i], values[i])
+		}
+	}
+	return nil
+}
+
+// Value returns the ent.Value that was dynamically selected and assigned to the Sev.
+// This includes values selected through modifiers, order, etc.
+func (s *Sev) Value(name string) (ent.Value, error) {
+	return s.selectValues.Get(name)
+}
+
+// QueryOwner queries the "owner" edge of the Sev entity.
+func (s *Sev) QueryOwner() *UserQuery {
+	return NewSevClient(s.config).QueryOwner(s)
+}
+
+// Update returns a builder for updating this Sev.
+// Note that you need to call Sev.Unwrap() before calling this method if this Sev
+// was returned from a transaction, and the transaction was committed or rolled back.
+func (s *Sev) Update() *SevUpdateOne {
+	return NewSevClient(s.config).UpdateOne(s)
+}
+
+// Unwrap unwraps the Sev entity that was returned from a transaction after it was closed,
+// so that all future queries will be executed through the driver which created the transaction.
+func (s *Sev) Unwrap() *Sev {
+	_tx, ok := s.config.driver.(*txDriver)
+	if !ok {
+		panic("ent: Sev is not a transactional entity")
+	}
+	s.config.driver = _tx.drv
+	return s
+}
+
+// String implements the fmt.Stringer.
+func (s *Sev) String() string {
+	var builder strings.Builder
+	builder.WriteString("Sev(")
+	builder.WriteString(fmt.Sprintf("id=%v, ", s.ID))
+	builder.WriteString("password=<sensitive>")
+	builder.WriteString(", ")
+	builder.WriteString("token=<sensitive>")
+	builder.WriteString(", ")
+	builder.WriteString("limit=")
+	builder.WriteString(fmt.Sprintf("%v", s.Limit))
+	builder.WriteString(", ")
+	builder.WriteString("count=")
+	builder.WriteString(fmt.Sprintf("%v", s.Count))
+	builder.WriteString(", ")
+	builder.WriteString("handle=")
+	builder.WriteString(s.Handle)
+	builder.WriteString(", ")
+	builder.WriteString("did=")
+	builder.WriteString(s.Did)
+	builder.WriteString(", ")
+	builder.WriteString("uid=")
+	builder.WriteString(fmt.Sprintf("%v", s.UID))
+	builder.WriteString(", ")
+	builder.WriteString("cid=")
+	builder.WriteString(fmt.Sprintf("%v", s.Cid))
+	builder.WriteString(", ")
+	builder.WriteString("cp=")
+	builder.WriteString(fmt.Sprintf("%v", s.Cp))
+	builder.WriteString(", ")
+	builder.WriteString("card=")
+	builder.WriteString(fmt.Sprintf("%v", s.Card))
+	builder.WriteString(", ")
+	builder.WriteString("updated_at=")
+	builder.WriteString(s.UpdatedAt.Format(time.ANSIC))
+	builder.WriteString(", ")
+	builder.WriteString("created_at=")
+	builder.WriteString(s.CreatedAt.Format(time.ANSIC))
+	builder.WriteByte(')')
+	return builder.String()
+}
+
+// Sevs is a parsable slice of Sev.
+type Sevs []*Sev

ent/sev/sev.go

@@ -0,0 +1,181 @@
+// Code generated by ent, DO NOT EDIT.
+
+package sev
+
+import (
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+const (
+	// Label holds the string label denoting the sev type in the database.
+	Label = "sev"
+	// FieldID holds the string denoting the id field in the database.
+	FieldID = "id"
+	// FieldPassword holds the string denoting the password field in the database.
+	FieldPassword = "password"
+	// FieldToken holds the string denoting the token field in the database.
+	FieldToken = "token"
+	// FieldLimit holds the string denoting the limit field in the database.
+	FieldLimit = "limit"
+	// FieldCount holds the string denoting the count field in the database.
+	FieldCount = "count"
+	// FieldHandle holds the string denoting the handle field in the database.
+	FieldHandle = "handle"
+	// FieldDid holds the string denoting the did field in the database.
+	FieldDid = "did"
+	// FieldUID holds the string denoting the uid field in the database.
+	FieldUID = "uid"
+	// FieldCid holds the string denoting the cid field in the database.
+	FieldCid = "cid"
+	// FieldCp holds the string denoting the cp field in the database.
+	FieldCp = "cp"
+	// FieldCard holds the string denoting the card field in the database.
+	FieldCard = "card"
+	// FieldUpdatedAt holds the string denoting the updated_at field in the database.
+	FieldUpdatedAt = "updated_at"
+	// FieldCreatedAt holds the string denoting the created_at field in the database.
+	FieldCreatedAt = "created_at"
+	// EdgeOwner holds the string denoting the owner edge name in mutations.
+	EdgeOwner = "owner"
+	// Table holds the table name of the sev in the database.
+	Table = "sevs"
+	// OwnerTable is the table that holds the owner relation/edge.
+	OwnerTable = "sevs"
+	// OwnerInverseTable is the table name for the User entity.
+	// It exists in this package in order to avoid circular dependency with the "user" package.
+	OwnerInverseTable = "users"
+	// OwnerColumn is the table column denoting the owner relation/edge.
+	OwnerColumn = "user_sev"
+)
+
+// Columns holds all SQL columns for sev fields.
+var Columns = []string{
+	FieldID,
+	FieldPassword,
+	FieldToken,
+	FieldLimit,
+	FieldCount,
+	FieldHandle,
+	FieldDid,
+	FieldUID,
+	FieldCid,
+	FieldCp,
+	FieldCard,
+	FieldUpdatedAt,
+	FieldCreatedAt,
+}
+
+// ForeignKeys holds the SQL foreign-keys that are owned by the "sevs"
+// table and are not defined as standalone fields in the schema.
+var ForeignKeys = []string{
+	"user_sev",
+}
+
+// ValidColumn reports if the column name is valid (part of the table columns).
+func ValidColumn(column string) bool {
+	for i := range Columns {
+		if column == Columns[i] {
+			return true
+		}
+	}
+	for i := range ForeignKeys {
+		if column == ForeignKeys[i] {
+			return true
+		}
+	}
+	return false
+}
+
+var (
+	// PasswordValidator is a validator for the "password" field. It is called by the builders before save.
+	PasswordValidator func(string) error
+	// DefaultLimit holds the default value on creation for the "limit" field.
+	DefaultLimit bool
+	// DefaultCreatedAt holds the default value on creation for the "created_at" field.
+	DefaultCreatedAt func() time.Time
+)
+
+// OrderOption defines the ordering options for the Sev queries.
+type OrderOption func(*sql.Selector)
+
+// ByID orders the results by the id field.
+func ByID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldID, opts...).ToFunc()
+}
+
+// ByPassword orders the results by the password field.
+func ByPassword(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldPassword, opts...).ToFunc()
+}
+
+// ByToken orders the results by the token field.
+func ByToken(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldToken, opts...).ToFunc()
+}
+
+// ByLimit orders the results by the limit field.
+func ByLimit(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldLimit, opts...).ToFunc()
+}
+
+// ByCount orders the results by the count field.
+func ByCount(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCount, opts...).ToFunc()
+}
+
+// ByHandle orders the results by the handle field.
+func ByHandle(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldHandle, opts...).ToFunc()
+}
+
+// ByDid orders the results by the did field.
+func ByDid(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldDid, opts...).ToFunc()
+}
+
+// ByUID orders the results by the uid field.
+func ByUID(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUID, opts...).ToFunc()
+}
+
+// ByCid orders the results by the cid field.
+func ByCid(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCid, opts...).ToFunc()
+}
+
+// ByCp orders the results by the cp field.
+func ByCp(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCp, opts...).ToFunc()
+}
+
+// ByCard orders the results by the card field.
+func ByCard(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCard, opts...).ToFunc()
+}
+
+// ByUpdatedAt orders the results by the updated_at field.
+func ByUpdatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldUpdatedAt, opts...).ToFunc()
+}
+
+// ByCreatedAt orders the results by the created_at field.
+func ByCreatedAt(opts ...sql.OrderTermOption) OrderOption {
+	return sql.OrderByField(FieldCreatedAt, opts...).ToFunc()
+}
+
+// ByOwnerField orders the results by owner field.
+func ByOwnerField(field string, opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newOwnerStep(), sql.OrderByField(field, opts...))
+	}
+}
+func newOwnerStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(OwnerInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn),
+	)
+}

ent/sev/where.go

@@ -0,0 +1,831 @@
+// Code generated by ent, DO NOT EDIT.
+
+package sev
+
+import (
+	"api/ent/predicate"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+)
+
+// ID filters vertices based on their ID field.
+func ID(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldID, id))
+}
+
+// IDEQ applies the EQ predicate on the ID field.
+func IDEQ(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldID, id))
+}
+
+// IDNEQ applies the NEQ predicate on the ID field.
+func IDNEQ(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldID, id))
+}
+
+// IDIn applies the In predicate on the ID field.
+func IDIn(ids ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldID, ids...))
+}
+
+// IDNotIn applies the NotIn predicate on the ID field.
+func IDNotIn(ids ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldID, ids...))
+}
+
+// IDGT applies the GT predicate on the ID field.
+func IDGT(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldID, id))
+}
+
+// IDGTE applies the GTE predicate on the ID field.
+func IDGTE(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldID, id))
+}
+
+// IDLT applies the LT predicate on the ID field.
+func IDLT(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldID, id))
+}
+
+// IDLTE applies the LTE predicate on the ID field.
+func IDLTE(id int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldID, id))
+}
+
+// Password applies equality check predicate on the "password" field. It's identical to PasswordEQ.
+func Password(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldPassword, v))
+}
+
+// Token applies equality check predicate on the "token" field. It's identical to TokenEQ.
+func Token(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldToken, v))
+}
+
+// Limit applies equality check predicate on the "limit" field. It's identical to LimitEQ.
+func Limit(v bool) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldLimit, v))
+}
+
+// Count applies equality check predicate on the "count" field. It's identical to CountEQ.
+func Count(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCount, v))
+}
+
+// Handle applies equality check predicate on the "handle" field. It's identical to HandleEQ.
+func Handle(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldHandle, v))
+}
+
+// Did applies equality check predicate on the "did" field. It's identical to DidEQ.
+func Did(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldDid, v))
+}
+
+// UID applies equality check predicate on the "uid" field. It's identical to UIDEQ.
+func UID(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldUID, v))
+}
+
+// Cid applies equality check predicate on the "cid" field. It's identical to CidEQ.
+func Cid(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCid, v))
+}
+
+// Cp applies equality check predicate on the "cp" field. It's identical to CpEQ.
+func Cp(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCp, v))
+}
+
+// Card applies equality check predicate on the "card" field. It's identical to CardEQ.
+func Card(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCard, v))
+}
+
+// UpdatedAt applies equality check predicate on the "updated_at" field. It's identical to UpdatedAtEQ.
+func UpdatedAt(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// CreatedAt applies equality check predicate on the "created_at" field. It's identical to CreatedAtEQ.
+func CreatedAt(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// PasswordEQ applies the EQ predicate on the "password" field.
+func PasswordEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldPassword, v))
+}
+
+// PasswordNEQ applies the NEQ predicate on the "password" field.
+func PasswordNEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldPassword, v))
+}
+
+// PasswordIn applies the In predicate on the "password" field.
+func PasswordIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldPassword, vs...))
+}
+
+// PasswordNotIn applies the NotIn predicate on the "password" field.
+func PasswordNotIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldPassword, vs...))
+}
+
+// PasswordGT applies the GT predicate on the "password" field.
+func PasswordGT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldPassword, v))
+}
+
+// PasswordGTE applies the GTE predicate on the "password" field.
+func PasswordGTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldPassword, v))
+}
+
+// PasswordLT applies the LT predicate on the "password" field.
+func PasswordLT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldPassword, v))
+}
+
+// PasswordLTE applies the LTE predicate on the "password" field.
+func PasswordLTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldPassword, v))
+}
+
+// PasswordContains applies the Contains predicate on the "password" field.
+func PasswordContains(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContains(FieldPassword, v))
+}
+
+// PasswordHasPrefix applies the HasPrefix predicate on the "password" field.
+func PasswordHasPrefix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasPrefix(FieldPassword, v))
+}
+
+// PasswordHasSuffix applies the HasSuffix predicate on the "password" field.
+func PasswordHasSuffix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasSuffix(FieldPassword, v))
+}
+
+// PasswordEqualFold applies the EqualFold predicate on the "password" field.
+func PasswordEqualFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEqualFold(FieldPassword, v))
+}
+
+// PasswordContainsFold applies the ContainsFold predicate on the "password" field.
+func PasswordContainsFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContainsFold(FieldPassword, v))
+}
+
+// TokenEQ applies the EQ predicate on the "token" field.
+func TokenEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldToken, v))
+}
+
+// TokenNEQ applies the NEQ predicate on the "token" field.
+func TokenNEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldToken, v))
+}
+
+// TokenIn applies the In predicate on the "token" field.
+func TokenIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldToken, vs...))
+}
+
+// TokenNotIn applies the NotIn predicate on the "token" field.
+func TokenNotIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldToken, vs...))
+}
+
+// TokenGT applies the GT predicate on the "token" field.
+func TokenGT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldToken, v))
+}
+
+// TokenGTE applies the GTE predicate on the "token" field.
+func TokenGTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldToken, v))
+}
+
+// TokenLT applies the LT predicate on the "token" field.
+func TokenLT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldToken, v))
+}
+
+// TokenLTE applies the LTE predicate on the "token" field.
+func TokenLTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldToken, v))
+}
+
+// TokenContains applies the Contains predicate on the "token" field.
+func TokenContains(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContains(FieldToken, v))
+}
+
+// TokenHasPrefix applies the HasPrefix predicate on the "token" field.
+func TokenHasPrefix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasPrefix(FieldToken, v))
+}
+
+// TokenHasSuffix applies the HasSuffix predicate on the "token" field.
+func TokenHasSuffix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasSuffix(FieldToken, v))
+}
+
+// TokenIsNil applies the IsNil predicate on the "token" field.
+func TokenIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldToken))
+}
+
+// TokenNotNil applies the NotNil predicate on the "token" field.
+func TokenNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldToken))
+}
+
+// TokenEqualFold applies the EqualFold predicate on the "token" field.
+func TokenEqualFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEqualFold(FieldToken, v))
+}
+
+// TokenContainsFold applies the ContainsFold predicate on the "token" field.
+func TokenContainsFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContainsFold(FieldToken, v))
+}
+
+// LimitEQ applies the EQ predicate on the "limit" field.
+func LimitEQ(v bool) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldLimit, v))
+}
+
+// LimitNEQ applies the NEQ predicate on the "limit" field.
+func LimitNEQ(v bool) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldLimit, v))
+}
+
+// LimitIsNil applies the IsNil predicate on the "limit" field.
+func LimitIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldLimit))
+}
+
+// LimitNotNil applies the NotNil predicate on the "limit" field.
+func LimitNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldLimit))
+}
+
+// CountEQ applies the EQ predicate on the "count" field.
+func CountEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCount, v))
+}
+
+// CountNEQ applies the NEQ predicate on the "count" field.
+func CountNEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldCount, v))
+}
+
+// CountIn applies the In predicate on the "count" field.
+func CountIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldCount, vs...))
+}
+
+// CountNotIn applies the NotIn predicate on the "count" field.
+func CountNotIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldCount, vs...))
+}
+
+// CountGT applies the GT predicate on the "count" field.
+func CountGT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldCount, v))
+}
+
+// CountGTE applies the GTE predicate on the "count" field.
+func CountGTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldCount, v))
+}
+
+// CountLT applies the LT predicate on the "count" field.
+func CountLT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldCount, v))
+}
+
+// CountLTE applies the LTE predicate on the "count" field.
+func CountLTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldCount, v))
+}
+
+// CountIsNil applies the IsNil predicate on the "count" field.
+func CountIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldCount))
+}
+
+// CountNotNil applies the NotNil predicate on the "count" field.
+func CountNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldCount))
+}
+
+// HandleEQ applies the EQ predicate on the "handle" field.
+func HandleEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldHandle, v))
+}
+
+// HandleNEQ applies the NEQ predicate on the "handle" field.
+func HandleNEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldHandle, v))
+}
+
+// HandleIn applies the In predicate on the "handle" field.
+func HandleIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldHandle, vs...))
+}
+
+// HandleNotIn applies the NotIn predicate on the "handle" field.
+func HandleNotIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldHandle, vs...))
+}
+
+// HandleGT applies the GT predicate on the "handle" field.
+func HandleGT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldHandle, v))
+}
+
+// HandleGTE applies the GTE predicate on the "handle" field.
+func HandleGTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldHandle, v))
+}
+
+// HandleLT applies the LT predicate on the "handle" field.
+func HandleLT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldHandle, v))
+}
+
+// HandleLTE applies the LTE predicate on the "handle" field.
+func HandleLTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldHandle, v))
+}
+
+// HandleContains applies the Contains predicate on the "handle" field.
+func HandleContains(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContains(FieldHandle, v))
+}
+
+// HandleHasPrefix applies the HasPrefix predicate on the "handle" field.
+func HandleHasPrefix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasPrefix(FieldHandle, v))
+}
+
+// HandleHasSuffix applies the HasSuffix predicate on the "handle" field.
+func HandleHasSuffix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasSuffix(FieldHandle, v))
+}
+
+// HandleIsNil applies the IsNil predicate on the "handle" field.
+func HandleIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldHandle))
+}
+
+// HandleNotNil applies the NotNil predicate on the "handle" field.
+func HandleNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldHandle))
+}
+
+// HandleEqualFold applies the EqualFold predicate on the "handle" field.
+func HandleEqualFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEqualFold(FieldHandle, v))
+}
+
+// HandleContainsFold applies the ContainsFold predicate on the "handle" field.
+func HandleContainsFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContainsFold(FieldHandle, v))
+}
+
+// DidEQ applies the EQ predicate on the "did" field.
+func DidEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldDid, v))
+}
+
+// DidNEQ applies the NEQ predicate on the "did" field.
+func DidNEQ(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldDid, v))
+}
+
+// DidIn applies the In predicate on the "did" field.
+func DidIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldDid, vs...))
+}
+
+// DidNotIn applies the NotIn predicate on the "did" field.
+func DidNotIn(vs ...string) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldDid, vs...))
+}
+
+// DidGT applies the GT predicate on the "did" field.
+func DidGT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldDid, v))
+}
+
+// DidGTE applies the GTE predicate on the "did" field.
+func DidGTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldDid, v))
+}
+
+// DidLT applies the LT predicate on the "did" field.
+func DidLT(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldDid, v))
+}
+
+// DidLTE applies the LTE predicate on the "did" field.
+func DidLTE(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldDid, v))
+}
+
+// DidContains applies the Contains predicate on the "did" field.
+func DidContains(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContains(FieldDid, v))
+}
+
+// DidHasPrefix applies the HasPrefix predicate on the "did" field.
+func DidHasPrefix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasPrefix(FieldDid, v))
+}
+
+// DidHasSuffix applies the HasSuffix predicate on the "did" field.
+func DidHasSuffix(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldHasSuffix(FieldDid, v))
+}
+
+// DidIsNil applies the IsNil predicate on the "did" field.
+func DidIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldDid))
+}
+
+// DidNotNil applies the NotNil predicate on the "did" field.
+func DidNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldDid))
+}
+
+// DidEqualFold applies the EqualFold predicate on the "did" field.
+func DidEqualFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldEqualFold(FieldDid, v))
+}
+
+// DidContainsFold applies the ContainsFold predicate on the "did" field.
+func DidContainsFold(v string) predicate.Sev {
+	return predicate.Sev(sql.FieldContainsFold(FieldDid, v))
+}
+
+// UIDEQ applies the EQ predicate on the "uid" field.
+func UIDEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldUID, v))
+}
+
+// UIDNEQ applies the NEQ predicate on the "uid" field.
+func UIDNEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldUID, v))
+}
+
+// UIDIn applies the In predicate on the "uid" field.
+func UIDIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldUID, vs...))
+}
+
+// UIDNotIn applies the NotIn predicate on the "uid" field.
+func UIDNotIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldUID, vs...))
+}
+
+// UIDGT applies the GT predicate on the "uid" field.
+func UIDGT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldUID, v))
+}
+
+// UIDGTE applies the GTE predicate on the "uid" field.
+func UIDGTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldUID, v))
+}
+
+// UIDLT applies the LT predicate on the "uid" field.
+func UIDLT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldUID, v))
+}
+
+// UIDLTE applies the LTE predicate on the "uid" field.
+func UIDLTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldUID, v))
+}
+
+// UIDIsNil applies the IsNil predicate on the "uid" field.
+func UIDIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldUID))
+}
+
+// UIDNotNil applies the NotNil predicate on the "uid" field.
+func UIDNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldUID))
+}
+
+// CidEQ applies the EQ predicate on the "cid" field.
+func CidEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCid, v))
+}
+
+// CidNEQ applies the NEQ predicate on the "cid" field.
+func CidNEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldCid, v))
+}
+
+// CidIn applies the In predicate on the "cid" field.
+func CidIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldCid, vs...))
+}
+
+// CidNotIn applies the NotIn predicate on the "cid" field.
+func CidNotIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldCid, vs...))
+}
+
+// CidGT applies the GT predicate on the "cid" field.
+func CidGT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldCid, v))
+}
+
+// CidGTE applies the GTE predicate on the "cid" field.
+func CidGTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldCid, v))
+}
+
+// CidLT applies the LT predicate on the "cid" field.
+func CidLT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldCid, v))
+}
+
+// CidLTE applies the LTE predicate on the "cid" field.
+func CidLTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldCid, v))
+}
+
+// CidIsNil applies the IsNil predicate on the "cid" field.
+func CidIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldCid))
+}
+
+// CidNotNil applies the NotNil predicate on the "cid" field.
+func CidNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldCid))
+}
+
+// CpEQ applies the EQ predicate on the "cp" field.
+func CpEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCp, v))
+}
+
+// CpNEQ applies the NEQ predicate on the "cp" field.
+func CpNEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldCp, v))
+}
+
+// CpIn applies the In predicate on the "cp" field.
+func CpIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldCp, vs...))
+}
+
+// CpNotIn applies the NotIn predicate on the "cp" field.
+func CpNotIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldCp, vs...))
+}
+
+// CpGT applies the GT predicate on the "cp" field.
+func CpGT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldCp, v))
+}
+
+// CpGTE applies the GTE predicate on the "cp" field.
+func CpGTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldCp, v))
+}
+
+// CpLT applies the LT predicate on the "cp" field.
+func CpLT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldCp, v))
+}
+
+// CpLTE applies the LTE predicate on the "cp" field.
+func CpLTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldCp, v))
+}
+
+// CpIsNil applies the IsNil predicate on the "cp" field.
+func CpIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldCp))
+}
+
+// CpNotNil applies the NotNil predicate on the "cp" field.
+func CpNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldCp))
+}
+
+// CardEQ applies the EQ predicate on the "card" field.
+func CardEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCard, v))
+}
+
+// CardNEQ applies the NEQ predicate on the "card" field.
+func CardNEQ(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldCard, v))
+}
+
+// CardIn applies the In predicate on the "card" field.
+func CardIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldCard, vs...))
+}
+
+// CardNotIn applies the NotIn predicate on the "card" field.
+func CardNotIn(vs ...int) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldCard, vs...))
+}
+
+// CardGT applies the GT predicate on the "card" field.
+func CardGT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldCard, v))
+}
+
+// CardGTE applies the GTE predicate on the "card" field.
+func CardGTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldCard, v))
+}
+
+// CardLT applies the LT predicate on the "card" field.
+func CardLT(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldCard, v))
+}
+
+// CardLTE applies the LTE predicate on the "card" field.
+func CardLTE(v int) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldCard, v))
+}
+
+// CardIsNil applies the IsNil predicate on the "card" field.
+func CardIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldCard))
+}
+
+// CardNotNil applies the NotNil predicate on the "card" field.
+func CardNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldCard))
+}
+
+// UpdatedAtEQ applies the EQ predicate on the "updated_at" field.
+func UpdatedAtEQ(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtNEQ applies the NEQ predicate on the "updated_at" field.
+func UpdatedAtNEQ(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIn applies the In predicate on the "updated_at" field.
+func UpdatedAtIn(vs ...time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtNotIn applies the NotIn predicate on the "updated_at" field.
+func UpdatedAtNotIn(vs ...time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldUpdatedAt, vs...))
+}
+
+// UpdatedAtGT applies the GT predicate on the "updated_at" field.
+func UpdatedAtGT(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtGTE applies the GTE predicate on the "updated_at" field.
+func UpdatedAtGTE(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLT applies the LT predicate on the "updated_at" field.
+func UpdatedAtLT(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldUpdatedAt, v))
+}
+
+// UpdatedAtLTE applies the LTE predicate on the "updated_at" field.
+func UpdatedAtLTE(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldUpdatedAt, v))
+}
+
+// UpdatedAtIsNil applies the IsNil predicate on the "updated_at" field.
+func UpdatedAtIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldUpdatedAt))
+}
+
+// UpdatedAtNotNil applies the NotNil predicate on the "updated_at" field.
+func UpdatedAtNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldUpdatedAt))
+}
+
+// CreatedAtEQ applies the EQ predicate on the "created_at" field.
+func CreatedAtEQ(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtNEQ applies the NEQ predicate on the "created_at" field.
+func CreatedAtNEQ(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldNEQ(FieldCreatedAt, v))
+}
+
+// CreatedAtIn applies the In predicate on the "created_at" field.
+func CreatedAtIn(vs ...time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtNotIn applies the NotIn predicate on the "created_at" field.
+func CreatedAtNotIn(vs ...time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldNotIn(FieldCreatedAt, vs...))
+}
+
+// CreatedAtGT applies the GT predicate on the "created_at" field.
+func CreatedAtGT(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldGT(FieldCreatedAt, v))
+}
+
+// CreatedAtGTE applies the GTE predicate on the "created_at" field.
+func CreatedAtGTE(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldGTE(FieldCreatedAt, v))
+}
+
+// CreatedAtLT applies the LT predicate on the "created_at" field.
+func CreatedAtLT(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldLT(FieldCreatedAt, v))
+}
+
+// CreatedAtLTE applies the LTE predicate on the "created_at" field.
+func CreatedAtLTE(v time.Time) predicate.Sev {
+	return predicate.Sev(sql.FieldLTE(FieldCreatedAt, v))
+}
+
+// CreatedAtIsNil applies the IsNil predicate on the "created_at" field.
+func CreatedAtIsNil() predicate.Sev {
+	return predicate.Sev(sql.FieldIsNull(FieldCreatedAt))
+}
+
+// CreatedAtNotNil applies the NotNil predicate on the "created_at" field.
+func CreatedAtNotNil() predicate.Sev {
+	return predicate.Sev(sql.FieldNotNull(FieldCreatedAt))
+}
+
+// HasOwner applies the HasEdge predicate on the "owner" edge.
+func HasOwner() predicate.Sev {
+	return predicate.Sev(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, OwnerTable, OwnerColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasOwnerWith applies the HasEdge predicate on the "owner" edge with a given conditions (other predicates).
+func HasOwnerWith(preds ...predicate.User) predicate.Sev {
+	return predicate.Sev(func(s *sql.Selector) {
+		step := newOwnerStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
+// And groups predicates with the AND operator between them.
+func And(predicates ...predicate.Sev) predicate.Sev {
+	return predicate.Sev(func(s *sql.Selector) {
+		s1 := s.Clone().SetP(nil)
+		for _, p := range predicates {
+			p(s1)
+		}
+		s.Where(s1.P())
+	})
+}
+
+// Or groups predicates with the OR operator between them.
+func Or(predicates ...predicate.Sev) predicate.Sev {
+	return predicate.Sev(func(s *sql.Selector) {
+		s1 := s.Clone().SetP(nil)
+		for i, p := range predicates {
+			if i > 0 {
+				s1.Or()
+			}
+			p(s1)
+		}
+		s.Where(s1.P())
+	})
+}
+
+// Not applies the not operator on the given predicate.
+func Not(p predicate.Sev) predicate.Sev {
+	return predicate.Sev(func(s *sql.Selector) {
+		p(s.Not())
+	})
+}

ent/sev_create.go

@@ -0,0 +1,429 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"api/ent/sev"
+	"api/ent/user"
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// SevCreate is the builder for creating a Sev entity.
+type SevCreate struct {
+	config
+	mutation *SevMutation
+	hooks    []Hook
+}
+
+// SetPassword sets the "password" field.
+func (sc *SevCreate) SetPassword(s string) *SevCreate {
+	sc.mutation.SetPassword(s)
+	return sc
+}
+
+// SetToken sets the "token" field.
+func (sc *SevCreate) SetToken(s string) *SevCreate {
+	sc.mutation.SetToken(s)
+	return sc
+}
+
+// SetNillableToken sets the "token" field if the given value is not nil.
+func (sc *SevCreate) SetNillableToken(s *string) *SevCreate {
+	if s != nil {
+		sc.SetToken(*s)
+	}
+	return sc
+}
+
+// SetLimit sets the "limit" field.
+func (sc *SevCreate) SetLimit(b bool) *SevCreate {
+	sc.mutation.SetLimit(b)
+	return sc
+}
+
+// SetNillableLimit sets the "limit" field if the given value is not nil.
+func (sc *SevCreate) SetNillableLimit(b *bool) *SevCreate {
+	if b != nil {
+		sc.SetLimit(*b)
+	}
+	return sc
+}
+
+// SetCount sets the "count" field.
+func (sc *SevCreate) SetCount(i int) *SevCreate {
+	sc.mutation.SetCount(i)
+	return sc
+}
+
+// SetNillableCount sets the "count" field if the given value is not nil.
+func (sc *SevCreate) SetNillableCount(i *int) *SevCreate {
+	if i != nil {
+		sc.SetCount(*i)
+	}
+	return sc
+}
+
+// SetHandle sets the "handle" field.
+func (sc *SevCreate) SetHandle(s string) *SevCreate {
+	sc.mutation.SetHandle(s)
+	return sc
+}
+
+// SetNillableHandle sets the "handle" field if the given value is not nil.
+func (sc *SevCreate) SetNillableHandle(s *string) *SevCreate {
+	if s != nil {
+		sc.SetHandle(*s)
+	}
+	return sc
+}
+
+// SetDid sets the "did" field.
+func (sc *SevCreate) SetDid(s string) *SevCreate {
+	sc.mutation.SetDid(s)
+	return sc
+}
+
+// SetNillableDid sets the "did" field if the given value is not nil.
+func (sc *SevCreate) SetNillableDid(s *string) *SevCreate {
+	if s != nil {
+		sc.SetDid(*s)
+	}
+	return sc
+}
+
+// SetUID sets the "uid" field.
+func (sc *SevCreate) SetUID(i int) *SevCreate {
+	sc.mutation.SetUID(i)
+	return sc
+}
+
+// SetNillableUID sets the "uid" field if the given value is not nil.
+func (sc *SevCreate) SetNillableUID(i *int) *SevCreate {
+	if i != nil {
+		sc.SetUID(*i)
+	}
+	return sc
+}
+
+// SetCid sets the "cid" field.
+func (sc *SevCreate) SetCid(i int) *SevCreate {
+	sc.mutation.SetCid(i)
+	return sc
+}
+
+// SetNillableCid sets the "cid" field if the given value is not nil.
+func (sc *SevCreate) SetNillableCid(i *int) *SevCreate {
+	if i != nil {
+		sc.SetCid(*i)
+	}
+	return sc
+}
+
+// SetCp sets the "cp" field.
+func (sc *SevCreate) SetCp(i int) *SevCreate {
+	sc.mutation.SetCp(i)
+	return sc
+}
+
+// SetNillableCp sets the "cp" field if the given value is not nil.
+func (sc *SevCreate) SetNillableCp(i *int) *SevCreate {
+	if i != nil {
+		sc.SetCp(*i)
+	}
+	return sc
+}
+
+// SetCard sets the "card" field.
+func (sc *SevCreate) SetCard(i int) *SevCreate {
+	sc.mutation.SetCard(i)
+	return sc
+}
+
+// SetNillableCard sets the "card" field if the given value is not nil.
+func (sc *SevCreate) SetNillableCard(i *int) *SevCreate {
+	if i != nil {
+		sc.SetCard(*i)
+	}
+	return sc
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (sc *SevCreate) SetUpdatedAt(t time.Time) *SevCreate {
+	sc.mutation.SetUpdatedAt(t)
+	return sc
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (sc *SevCreate) SetNillableUpdatedAt(t *time.Time) *SevCreate {
+	if t != nil {
+		sc.SetUpdatedAt(*t)
+	}
+	return sc
+}
+
+// SetCreatedAt sets the "created_at" field.
+func (sc *SevCreate) SetCreatedAt(t time.Time) *SevCreate {
+	sc.mutation.SetCreatedAt(t)
+	return sc
+}
+
+// SetNillableCreatedAt sets the "created_at" field if the given value is not nil.
+func (sc *SevCreate) SetNillableCreatedAt(t *time.Time) *SevCreate {
+	if t != nil {
+		sc.SetCreatedAt(*t)
+	}
+	return sc
+}
+
+// SetOwnerID sets the "owner" edge to the User entity by ID.
+func (sc *SevCreate) SetOwnerID(id int) *SevCreate {
+	sc.mutation.SetOwnerID(id)
+	return sc
+}
+
+// SetOwner sets the "owner" edge to the User entity.
+func (sc *SevCreate) SetOwner(u *User) *SevCreate {
+	return sc.SetOwnerID(u.ID)
+}
+
+// Mutation returns the SevMutation object of the builder.
+func (sc *SevCreate) Mutation() *SevMutation {
+	return sc.mutation
+}
+
+// Save creates the Sev in the database.
+func (sc *SevCreate) Save(ctx context.Context) (*Sev, error) {
+	sc.defaults()
+	return withHooks[*Sev, SevMutation](ctx, sc.sqlSave, sc.mutation, sc.hooks)
+}
+
+// SaveX calls Save and panics if Save returns an error.
+func (sc *SevCreate) SaveX(ctx context.Context) *Sev {
+	v, err := sc.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (sc *SevCreate) Exec(ctx context.Context) error {
+	_, err := sc.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sc *SevCreate) ExecX(ctx context.Context) {
+	if err := sc.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// defaults sets the default values of the builder before save.
+func (sc *SevCreate) defaults() {
+	if _, ok := sc.mutation.Limit(); !ok {
+		v := sev.DefaultLimit
+		sc.mutation.SetLimit(v)
+	}
+	if _, ok := sc.mutation.CreatedAt(); !ok {
+		v := sev.DefaultCreatedAt()
+		sc.mutation.SetCreatedAt(v)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (sc *SevCreate) check() error {
+	if _, ok := sc.mutation.Password(); !ok {
+		return &ValidationError{Name: "password", err: errors.New(`ent: missing required field "Sev.password"`)}
+	}
+	if v, ok := sc.mutation.Password(); ok {
+		if err := sev.PasswordValidator(v); err != nil {
+			return &ValidationError{Name: "password", err: fmt.Errorf(`ent: validator failed for field "Sev.password": %w`, err)}
+		}
+	}
+	if _, ok := sc.mutation.OwnerID(); !ok {
+		return &ValidationError{Name: "owner", err: errors.New(`ent: missing required edge "Sev.owner"`)}
+	}
+	return nil
+}
+
+func (sc *SevCreate) sqlSave(ctx context.Context) (*Sev, error) {
+	if err := sc.check(); err != nil {
+		return nil, err
+	}
+	_node, _spec := sc.createSpec()
+	if err := sqlgraph.CreateNode(ctx, sc.driver, _spec); err != nil {
+		if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	id := _spec.ID.Value.(int64)
+	_node.ID = int(id)
+	sc.mutation.id = &_node.ID
+	sc.mutation.done = true
+	return _node, nil
+}
+
+func (sc *SevCreate) createSpec() (*Sev, *sqlgraph.CreateSpec) {
+	var (
+		_node = &Sev{config: sc.config}
+		_spec = sqlgraph.NewCreateSpec(sev.Table, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt))
+	)
+	if value, ok := sc.mutation.Password(); ok {
+		_spec.SetField(sev.FieldPassword, field.TypeString, value)
+		_node.Password = value
+	}
+	if value, ok := sc.mutation.Token(); ok {
+		_spec.SetField(sev.FieldToken, field.TypeString, value)
+		_node.Token = value
+	}
+	if value, ok := sc.mutation.Limit(); ok {
+		_spec.SetField(sev.FieldLimit, field.TypeBool, value)
+		_node.Limit = value
+	}
+	if value, ok := sc.mutation.Count(); ok {
+		_spec.SetField(sev.FieldCount, field.TypeInt, value)
+		_node.Count = value
+	}
+	if value, ok := sc.mutation.Handle(); ok {
+		_spec.SetField(sev.FieldHandle, field.TypeString, value)
+		_node.Handle = value
+	}
+	if value, ok := sc.mutation.Did(); ok {
+		_spec.SetField(sev.FieldDid, field.TypeString, value)
+		_node.Did = value
+	}
+	if value, ok := sc.mutation.UID(); ok {
+		_spec.SetField(sev.FieldUID, field.TypeInt, value)
+		_node.UID = value
+	}
+	if value, ok := sc.mutation.Cid(); ok {
+		_spec.SetField(sev.FieldCid, field.TypeInt, value)
+		_node.Cid = value
+	}
+	if value, ok := sc.mutation.Cp(); ok {
+		_spec.SetField(sev.FieldCp, field.TypeInt, value)
+		_node.Cp = value
+	}
+	if value, ok := sc.mutation.Card(); ok {
+		_spec.SetField(sev.FieldCard, field.TypeInt, value)
+		_node.Card = value
+	}
+	if value, ok := sc.mutation.UpdatedAt(); ok {
+		_spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value)
+		_node.UpdatedAt = value
+	}
+	if value, ok := sc.mutation.CreatedAt(); ok {
+		_spec.SetField(sev.FieldCreatedAt, field.TypeTime, value)
+		_node.CreatedAt = value
+	}
+	if nodes := sc.mutation.OwnerIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   sev.OwnerTable,
+			Columns: []string{sev.OwnerColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_node.user_sev = &nodes[0]
+		_spec.Edges = append(_spec.Edges, edge)
+	}
+	return _node, _spec
+}
+
+// SevCreateBulk is the builder for creating many Sev entities in bulk.
+type SevCreateBulk struct {
+	config
+	builders []*SevCreate
+}
+
+// Save creates the Sev entities in the database.
+func (scb *SevCreateBulk) Save(ctx context.Context) ([]*Sev, error) {
+	specs := make([]*sqlgraph.CreateSpec, len(scb.builders))
+	nodes := make([]*Sev, len(scb.builders))
+	mutators := make([]Mutator, len(scb.builders))
+	for i := range scb.builders {
+		func(i int, root context.Context) {
+			builder := scb.builders[i]
+			builder.defaults()
+			var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
+				mutation, ok := m.(*SevMutation)
+				if !ok {
+					return nil, fmt.Errorf("unexpected mutation type %T", m)
+				}
+				if err := builder.check(); err != nil {
+					return nil, err
+				}
+				builder.mutation = mutation
+				var err error
+				nodes[i], specs[i] = builder.createSpec()
+				if i < len(mutators)-1 {
+					_, err = mutators[i+1].Mutate(root, scb.builders[i+1].mutation)
+				} else {
+					spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
+					// Invoke the actual operation on the latest mutation in the chain.
+					if err = sqlgraph.BatchCreate(ctx, scb.driver, spec); err != nil {
+						if sqlgraph.IsConstraintError(err) {
+							err = &ConstraintError{msg: err.Error(), wrap: err}
+						}
+					}
+				}
+				if err != nil {
+					return nil, err
+				}
+				mutation.id = &nodes[i].ID
+				if specs[i].ID.Value != nil {
+					id := specs[i].ID.Value.(int64)
+					nodes[i].ID = int(id)
+				}
+				mutation.done = true
+				return nodes[i], nil
+			})
+			for i := len(builder.hooks) - 1; i >= 0; i-- {
+				mut = builder.hooks[i](mut)
+			}
+			mutators[i] = mut
+		}(i, ctx)
+	}
+	if len(mutators) > 0 {
+		if _, err := mutators[0].Mutate(ctx, scb.builders[0].mutation); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (scb *SevCreateBulk) SaveX(ctx context.Context) []*Sev {
+	v, err := scb.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return v
+}
+
+// Exec executes the query.
+func (scb *SevCreateBulk) Exec(ctx context.Context) error {
+	_, err := scb.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (scb *SevCreateBulk) ExecX(ctx context.Context) {
+	if err := scb.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

ent/sev_delete.go

@@ -0,0 +1,88 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"api/ent/predicate"
+	"api/ent/sev"
+	"context"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// SevDelete is the builder for deleting a Sev entity.
+type SevDelete struct {
+	config
+	hooks    []Hook
+	mutation *SevMutation
+}
+
+// Where appends a list predicates to the SevDelete builder.
+func (sd *SevDelete) Where(ps ...predicate.Sev) *SevDelete {
+	sd.mutation.Where(ps...)
+	return sd
+}
+
+// Exec executes the deletion query and returns how many vertices were deleted.
+func (sd *SevDelete) Exec(ctx context.Context) (int, error) {
+	return withHooks[int, SevMutation](ctx, sd.sqlExec, sd.mutation, sd.hooks)
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sd *SevDelete) ExecX(ctx context.Context) int {
+	n, err := sd.Exec(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return n
+}
+
+func (sd *SevDelete) sqlExec(ctx context.Context) (int, error) {
+	_spec := sqlgraph.NewDeleteSpec(sev.Table, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt))
+	if ps := sd.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	affected, err := sqlgraph.DeleteNodes(ctx, sd.driver, _spec)
+	if err != nil && sqlgraph.IsConstraintError(err) {
+		err = &ConstraintError{msg: err.Error(), wrap: err}
+	}
+	sd.mutation.done = true
+	return affected, err
+}
+
+// SevDeleteOne is the builder for deleting a single Sev entity.
+type SevDeleteOne struct {
+	sd *SevDelete
+}
+
+// Where appends a list predicates to the SevDelete builder.
+func (sdo *SevDeleteOne) Where(ps ...predicate.Sev) *SevDeleteOne {
+	sdo.sd.mutation.Where(ps...)
+	return sdo
+}
+
+// Exec executes the deletion query.
+func (sdo *SevDeleteOne) Exec(ctx context.Context) error {
+	n, err := sdo.sd.Exec(ctx)
+	switch {
+	case err != nil:
+		return err
+	case n == 0:
+		return &NotFoundError{sev.Label}
+	default:
+		return nil
+	}
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (sdo *SevDeleteOne) ExecX(ctx context.Context) {
+	if err := sdo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}

ent/sev_query.go

@@ -0,0 +1,613 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"api/ent/predicate"
+	"api/ent/sev"
+	"api/ent/user"
+	"context"
+	"fmt"
+	"math"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// SevQuery is the builder for querying Sev entities.
+type SevQuery struct {
+	config
+	ctx        *QueryContext
+	order      []sev.OrderOption
+	inters     []Interceptor
+	predicates []predicate.Sev
+	withOwner  *UserQuery
+	withFKs    bool
+	// intermediate query (i.e. traversal path).
+	sql  *sql.Selector
+	path func(context.Context) (*sql.Selector, error)
+}
+
+// Where adds a new predicate for the SevQuery builder.
+func (sq *SevQuery) Where(ps ...predicate.Sev) *SevQuery {
+	sq.predicates = append(sq.predicates, ps...)
+	return sq
+}
+
+// Limit the number of records to be returned by this query.
+func (sq *SevQuery) Limit(limit int) *SevQuery {
+	sq.ctx.Limit = &limit
+	return sq
+}
+
+// Offset to start from.
+func (sq *SevQuery) Offset(offset int) *SevQuery {
+	sq.ctx.Offset = &offset
+	return sq
+}
+
+// Unique configures the query builder to filter duplicate records on query.
+// By default, unique is set to true, and can be disabled using this method.
+func (sq *SevQuery) Unique(unique bool) *SevQuery {
+	sq.ctx.Unique = &unique
+	return sq
+}
+
+// Order specifies how the records should be ordered.
+func (sq *SevQuery) Order(o ...sev.OrderOption) *SevQuery {
+	sq.order = append(sq.order, o...)
+	return sq
+}
+
+// QueryOwner chains the current query on the "owner" edge.
+func (sq *SevQuery) QueryOwner() *UserQuery {
+	query := (&UserClient{config: sq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := sq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := sq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(sev.Table, sev.FieldID, selector),
+			sqlgraph.To(user.Table, user.FieldID),
+			sqlgraph.Edge(sqlgraph.M2O, true, sev.OwnerTable, sev.OwnerColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(sq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
+// First returns the first Sev entity from the query.
+// Returns a *NotFoundError when no Sev was found.
+func (sq *SevQuery) First(ctx context.Context) (*Sev, error) {
+	nodes, err := sq.Limit(1).All(setContextOp(ctx, sq.ctx, "First"))
+	if err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nil, &NotFoundError{sev.Label}
+	}
+	return nodes[0], nil
+}
+
+// FirstX is like First, but panics if an error occurs.
+func (sq *SevQuery) FirstX(ctx context.Context) *Sev {
+	node, err := sq.First(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return node
+}
+
+// FirstID returns the first Sev ID from the query.
+// Returns a *NotFoundError when no Sev ID was found.
+func (sq *SevQuery) FirstID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = sq.Limit(1).IDs(setContextOp(ctx, sq.ctx, "FirstID")); err != nil {
+		return
+	}
+	if len(ids) == 0 {
+		err = &NotFoundError{sev.Label}
+		return
+	}
+	return ids[0], nil
+}
+
+// FirstIDX is like FirstID, but panics if an error occurs.
+func (sq *SevQuery) FirstIDX(ctx context.Context) int {
+	id, err := sq.FirstID(ctx)
+	if err != nil && !IsNotFound(err) {
+		panic(err)
+	}
+	return id
+}
+
+// Only returns a single Sev entity found by the query, ensuring it only returns one.
+// Returns a *NotSingularError when more than one Sev entity is found.
+// Returns a *NotFoundError when no Sev entities are found.
+func (sq *SevQuery) Only(ctx context.Context) (*Sev, error) {
+	nodes, err := sq.Limit(2).All(setContextOp(ctx, sq.ctx, "Only"))
+	if err != nil {
+		return nil, err
+	}
+	switch len(nodes) {
+	case 1:
+		return nodes[0], nil
+	case 0:
+		return nil, &NotFoundError{sev.Label}
+	default:
+		return nil, &NotSingularError{sev.Label}
+	}
+}
+
+// OnlyX is like Only, but panics if an error occurs.
+func (sq *SevQuery) OnlyX(ctx context.Context) *Sev {
+	node, err := sq.Only(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// OnlyID is like Only, but returns the only Sev ID in the query.
+// Returns a *NotSingularError when more than one Sev ID is found.
+// Returns a *NotFoundError when no entities are found.
+func (sq *SevQuery) OnlyID(ctx context.Context) (id int, err error) {
+	var ids []int
+	if ids, err = sq.Limit(2).IDs(setContextOp(ctx, sq.ctx, "OnlyID")); err != nil {
+		return
+	}
+	switch len(ids) {
+	case 1:
+		id = ids[0]
+	case 0:
+		err = &NotFoundError{sev.Label}
+	default:
+		err = &NotSingularError{sev.Label}
+	}
+	return
+}
+
+// OnlyIDX is like OnlyID, but panics if an error occurs.
+func (sq *SevQuery) OnlyIDX(ctx context.Context) int {
+	id, err := sq.OnlyID(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return id
+}
+
+// All executes the query and returns a list of Sevs.
+func (sq *SevQuery) All(ctx context.Context) ([]*Sev, error) {
+	ctx = setContextOp(ctx, sq.ctx, "All")
+	if err := sq.prepareQuery(ctx); err != nil {
+		return nil, err
+	}
+	qr := querierAll[[]*Sev, *SevQuery]()
+	return withInterceptors[[]*Sev](ctx, sq, qr, sq.inters)
+}
+
+// AllX is like All, but panics if an error occurs.
+func (sq *SevQuery) AllX(ctx context.Context) []*Sev {
+	nodes, err := sq.All(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return nodes
+}
+
+// IDs executes the query and returns a list of Sev IDs.
+func (sq *SevQuery) IDs(ctx context.Context) (ids []int, err error) {
+	if sq.ctx.Unique == nil && sq.path != nil {
+		sq.Unique(true)
+	}
+	ctx = setContextOp(ctx, sq.ctx, "IDs")
+	if err = sq.Select(sev.FieldID).Scan(ctx, &ids); err != nil {
+		return nil, err
+	}
+	return ids, nil
+}
+
+// IDsX is like IDs, but panics if an error occurs.
+func (sq *SevQuery) IDsX(ctx context.Context) []int {
+	ids, err := sq.IDs(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return ids
+}
+
+// Count returns the count of the given query.
+func (sq *SevQuery) Count(ctx context.Context) (int, error) {
+	ctx = setContextOp(ctx, sq.ctx, "Count")
+	if err := sq.prepareQuery(ctx); err != nil {
+		return 0, err
+	}
+	return withInterceptors[int](ctx, sq, querierCount[*SevQuery](), sq.inters)
+}
+
+// CountX is like Count, but panics if an error occurs.
+func (sq *SevQuery) CountX(ctx context.Context) int {
+	count, err := sq.Count(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return count
+}
+
+// Exist returns true if the query has elements in the graph.
+func (sq *SevQuery) Exist(ctx context.Context) (bool, error) {
+	ctx = setContextOp(ctx, sq.ctx, "Exist")
+	switch _, err := sq.FirstID(ctx); {
+	case IsNotFound(err):
+		return false, nil
+	case err != nil:
+		return false, fmt.Errorf("ent: check existence: %w", err)
+	default:
+		return true, nil
+	}
+}
+
+// ExistX is like Exist, but panics if an error occurs.
+func (sq *SevQuery) ExistX(ctx context.Context) bool {
+	exist, err := sq.Exist(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return exist
+}
+
+// Clone returns a duplicate of the SevQuery builder, including all associated steps. It can be
+// used to prepare common query builders and use them differently after the clone is made.
+func (sq *SevQuery) Clone() *SevQuery {
+	if sq == nil {
+		return nil
+	}
+	return &SevQuery{
+		config:     sq.config,
+		ctx:        sq.ctx.Clone(),
+		order:      append([]sev.OrderOption{}, sq.order...),
+		inters:     append([]Interceptor{}, sq.inters...),
+		predicates: append([]predicate.Sev{}, sq.predicates...),
+		withOwner:  sq.withOwner.Clone(),
+		// clone intermediate query.
+		sql:  sq.sql.Clone(),
+		path: sq.path,
+	}
+}
+
+// WithOwner tells the query-builder to eager-load the nodes that are connected to
+// the "owner" edge. The optional arguments are used to configure the query builder of the edge.
+func (sq *SevQuery) WithOwner(opts ...func(*UserQuery)) *SevQuery {
+	query := (&UserClient{config: sq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	sq.withOwner = query
+	return sq
+}
+
+// GroupBy is used to group vertices by one or more fields/columns.
+// It is often used with aggregate functions, like: count, max, mean, min, sum.
+//
+// Example:
+//
+//	var v []struct {
+//		Password string `json:"password,omitempty"`
+//		Count int `json:"count,omitempty"`
+//	}
+//
+//	client.Sev.Query().
+//		GroupBy(sev.FieldPassword).
+//		Aggregate(ent.Count()).
+//		Scan(ctx, &v)
+func (sq *SevQuery) GroupBy(field string, fields ...string) *SevGroupBy {
+	sq.ctx.Fields = append([]string{field}, fields...)
+	grbuild := &SevGroupBy{build: sq}
+	grbuild.flds = &sq.ctx.Fields
+	grbuild.label = sev.Label
+	grbuild.scan = grbuild.Scan
+	return grbuild
+}
+
+// Select allows the selection one or more fields/columns for the given query,
+// instead of selecting all fields in the entity.
+//
+// Example:
+//
+//	var v []struct {
+//		Password string `json:"password,omitempty"`
+//	}
+//
+//	client.Sev.Query().
+//		Select(sev.FieldPassword).
+//		Scan(ctx, &v)
+func (sq *SevQuery) Select(fields ...string) *SevSelect {
+	sq.ctx.Fields = append(sq.ctx.Fields, fields...)
+	sbuild := &SevSelect{SevQuery: sq}
+	sbuild.label = sev.Label
+	sbuild.flds, sbuild.scan = &sq.ctx.Fields, sbuild.Scan
+	return sbuild
+}
+
+// Aggregate returns a SevSelect configured with the given aggregations.
+func (sq *SevQuery) Aggregate(fns ...AggregateFunc) *SevSelect {
+	return sq.Select().Aggregate(fns...)
+}
+
+func (sq *SevQuery) prepareQuery(ctx context.Context) error {
+	for _, inter := range sq.inters {
+		if inter == nil {
+			return fmt.Errorf("ent: uninitialized interceptor (forgotten import ent/runtime?)")
+		}
+		if trv, ok := inter.(Traverser); ok {
+			if err := trv.Traverse(ctx, sq); err != nil {
+				return err
+			}
+		}
+	}
+	for _, f := range sq.ctx.Fields {
+		if !sev.ValidColumn(f) {
+			return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+		}
+	}
+	if sq.path != nil {
+		prev, err := sq.path(ctx)
+		if err != nil {
+			return err
+		}
+		sq.sql = prev
+	}
+	return nil
+}
+
+func (sq *SevQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Sev, error) {
+	var (
+		nodes       = []*Sev{}
+		withFKs     = sq.withFKs
+		_spec       = sq.querySpec()
+		loadedTypes = [1]bool{
+			sq.withOwner != nil,
+		}
+	)
+	if sq.withOwner != nil {
+		withFKs = true
+	}
+	if withFKs {
+		_spec.Node.Columns = append(_spec.Node.Columns, sev.ForeignKeys...)
+	}
+	_spec.ScanValues = func(columns []string) ([]any, error) {
+		return (*Sev).scanValues(nil, columns)
+	}
+	_spec.Assign = func(columns []string, values []any) error {
+		node := &Sev{config: sq.config}
+		nodes = append(nodes, node)
+		node.Edges.loadedTypes = loadedTypes
+		return node.assignValues(columns, values)
+	}
+	for i := range hooks {
+		hooks[i](ctx, _spec)
+	}
+	if err := sqlgraph.QueryNodes(ctx, sq.driver, _spec); err != nil {
+		return nil, err
+	}
+	if len(nodes) == 0 {
+		return nodes, nil
+	}
+	if query := sq.withOwner; query != nil {
+		if err := sq.loadOwner(ctx, query, nodes, nil,
+			func(n *Sev, e *User) { n.Edges.Owner = e }); err != nil {
+			return nil, err
+		}
+	}
+	return nodes, nil
+}
+
+func (sq *SevQuery) loadOwner(ctx context.Context, query *UserQuery, nodes []*Sev, init func(*Sev), assign func(*Sev, *User)) error {
+	ids := make([]int, 0, len(nodes))
+	nodeids := make(map[int][]*Sev)
+	for i := range nodes {
+		if nodes[i].user_sev == nil {
+			continue
+		}
+		fk := *nodes[i].user_sev
+		if _, ok := nodeids[fk]; !ok {
+			ids = append(ids, fk)
+		}
+		nodeids[fk] = append(nodeids[fk], nodes[i])
+	}
+	if len(ids) == 0 {
+		return nil
+	}
+	query.Where(user.IDIn(ids...))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		nodes, ok := nodeids[n.ID]
+		if !ok {
+			return fmt.Errorf(`unexpected foreign-key "user_sev" returned %v`, n.ID)
+		}
+		for i := range nodes {
+			assign(nodes[i], n)
+		}
+	}
+	return nil
+}
+
+func (sq *SevQuery) sqlCount(ctx context.Context) (int, error) {
+	_spec := sq.querySpec()
+	_spec.Node.Columns = sq.ctx.Fields
+	if len(sq.ctx.Fields) > 0 {
+		_spec.Unique = sq.ctx.Unique != nil && *sq.ctx.Unique
+	}
+	return sqlgraph.CountNodes(ctx, sq.driver, _spec)
+}
+
+func (sq *SevQuery) querySpec() *sqlgraph.QuerySpec {
+	_spec := sqlgraph.NewQuerySpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt))
+	_spec.From = sq.sql
+	if unique := sq.ctx.Unique; unique != nil {
+		_spec.Unique = *unique
+	} else if sq.path != nil {
+		_spec.Unique = true
+	}
+	if fields := sq.ctx.Fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, sev.FieldID)
+		for i := range fields {
+			if fields[i] != sev.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
+			}
+		}
+	}
+	if ps := sq.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if limit := sq.ctx.Limit; limit != nil {
+		_spec.Limit = *limit
+	}
+	if offset := sq.ctx.Offset; offset != nil {
+		_spec.Offset = *offset
+	}
+	if ps := sq.order; len(ps) > 0 {
+		_spec.Order = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	return _spec
+}
+
+func (sq *SevQuery) sqlQuery(ctx context.Context) *sql.Selector {
+	builder := sql.Dialect(sq.driver.Dialect())
+	t1 := builder.Table(sev.Table)
+	columns := sq.ctx.Fields
+	if len(columns) == 0 {
+		columns = sev.Columns
+	}
+	selector := builder.Select(t1.Columns(columns...)...).From(t1)
+	if sq.sql != nil {
+		selector = sq.sql
+		selector.Select(selector.Columns(columns...)...)
+	}
+	if sq.ctx.Unique != nil && *sq.ctx.Unique {
+		selector.Distinct()
+	}
+	for _, p := range sq.predicates {
+		p(selector)
+	}
+	for _, p := range sq.order {
+		p(selector)
+	}
+	if offset := sq.ctx.Offset; offset != nil {
+		// limit is mandatory for offset clause. We start
+		// with default value, and override it below if needed.
+		selector.Offset(*offset).Limit(math.MaxInt32)
+	}
+	if limit := sq.ctx.Limit; limit != nil {
+		selector.Limit(*limit)
+	}
+	return selector
+}
+
+// SevGroupBy is the group-by builder for Sev entities.
+type SevGroupBy struct {
+	selector
+	build *SevQuery
+}
+
+// Aggregate adds the given aggregation functions to the group-by query.
+func (sgb *SevGroupBy) Aggregate(fns ...AggregateFunc) *SevGroupBy {
+	sgb.fns = append(sgb.fns, fns...)
+	return sgb
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (sgb *SevGroupBy) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, sgb.build.ctx, "GroupBy")
+	if err := sgb.build.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*SevQuery, *SevGroupBy](ctx, sgb.build, sgb, sgb.build.inters, v)
+}
+
+func (sgb *SevGroupBy) sqlScan(ctx context.Context, root *SevQuery, v any) error {
+	selector := root.sqlQuery(ctx).Select()
+	aggregation := make([]string, 0, len(sgb.fns))
+	for _, fn := range sgb.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	if len(selector.SelectedColumns()) == 0 {
+		columns := make([]string, 0, len(*sgb.flds)+len(sgb.fns))
+		for _, f := range *sgb.flds {
+			columns = append(columns, selector.C(f))
+		}
+		columns = append(columns, aggregation...)
+		selector.Select(columns...)
+	}
+	selector.GroupBy(selector.Columns(*sgb.flds...)...)
+	if err := selector.Err(); err != nil {
+		return err
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := sgb.build.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}
+
+// SevSelect is the builder for selecting fields of Sev entities.
+type SevSelect struct {
+	*SevQuery
+	selector
+}
+
+// Aggregate adds the given aggregation functions to the selector query.
+func (ss *SevSelect) Aggregate(fns ...AggregateFunc) *SevSelect {
+	ss.fns = append(ss.fns, fns...)
+	return ss
+}
+
+// Scan applies the selector query and scans the result into the given value.
+func (ss *SevSelect) Scan(ctx context.Context, v any) error {
+	ctx = setContextOp(ctx, ss.ctx, "Select")
+	if err := ss.prepareQuery(ctx); err != nil {
+		return err
+	}
+	return scanWithInterceptors[*SevQuery, *SevSelect](ctx, ss.SevQuery, ss, ss.inters, v)
+}
+
+func (ss *SevSelect) sqlScan(ctx context.Context, root *SevQuery, v any) error {
+	selector := root.sqlQuery(ctx)
+	aggregation := make([]string, 0, len(ss.fns))
+	for _, fn := range ss.fns {
+		aggregation = append(aggregation, fn(selector))
+	}
+	switch n := len(*ss.selector.flds); {
+	case n == 0 && len(aggregation) > 0:
+		selector.Select(aggregation...)
+	case n != 0 && len(aggregation) > 0:
+		selector.AppendSelect(aggregation...)
+	}
+	rows := &sql.Rows{}
+	query, args := selector.Query()
+	if err := ss.driver.Query(ctx, query, args, rows); err != nil {
+		return err
+	}
+	defer rows.Close()
+	return sql.ScanSlice(rows, v)
+}

ent/sev_update.go

@@ -0,0 +1,917 @@
+// Code generated by ent, DO NOT EDIT.
+
+package ent
+
+import (
+	"api/ent/predicate"
+	"api/ent/sev"
+	"api/ent/user"
+	"context"
+	"errors"
+	"fmt"
+	"time"
+
+	"entgo.io/ent/dialect/sql"
+	"entgo.io/ent/dialect/sql/sqlgraph"
+	"entgo.io/ent/schema/field"
+)
+
+// SevUpdate is the builder for updating Sev entities.
+type SevUpdate struct {
+	config
+	hooks    []Hook
+	mutation *SevMutation
+}
+
+// Where appends a list predicates to the SevUpdate builder.
+func (su *SevUpdate) Where(ps ...predicate.Sev) *SevUpdate {
+	su.mutation.Where(ps...)
+	return su
+}
+
+// SetToken sets the "token" field.
+func (su *SevUpdate) SetToken(s string) *SevUpdate {
+	su.mutation.SetToken(s)
+	return su
+}
+
+// SetNillableToken sets the "token" field if the given value is not nil.
+func (su *SevUpdate) SetNillableToken(s *string) *SevUpdate {
+	if s != nil {
+		su.SetToken(*s)
+	}
+	return su
+}
+
+// ClearToken clears the value of the "token" field.
+func (su *SevUpdate) ClearToken() *SevUpdate {
+	su.mutation.ClearToken()
+	return su
+}
+
+// SetLimit sets the "limit" field.
+func (su *SevUpdate) SetLimit(b bool) *SevUpdate {
+	su.mutation.SetLimit(b)
+	return su
+}
+
+// SetNillableLimit sets the "limit" field if the given value is not nil.
+func (su *SevUpdate) SetNillableLimit(b *bool) *SevUpdate {
+	if b != nil {
+		su.SetLimit(*b)
+	}
+	return su
+}
+
+// ClearLimit clears the value of the "limit" field.
+func (su *SevUpdate) ClearLimit() *SevUpdate {
+	su.mutation.ClearLimit()
+	return su
+}
+
+// SetCount sets the "count" field.
+func (su *SevUpdate) SetCount(i int) *SevUpdate {
+	su.mutation.ResetCount()
+	su.mutation.SetCount(i)
+	return su
+}
+
+// SetNillableCount sets the "count" field if the given value is not nil.
+func (su *SevUpdate) SetNillableCount(i *int) *SevUpdate {
+	if i != nil {
+		su.SetCount(*i)
+	}
+	return su
+}
+
+// AddCount adds i to the "count" field.
+func (su *SevUpdate) AddCount(i int) *SevUpdate {
+	su.mutation.AddCount(i)
+	return su
+}
+
+// ClearCount clears the value of the "count" field.
+func (su *SevUpdate) ClearCount() *SevUpdate {
+	su.mutation.ClearCount()
+	return su
+}
+
+// SetHandle sets the "handle" field.
+func (su *SevUpdate) SetHandle(s string) *SevUpdate {
+	su.mutation.SetHandle(s)
+	return su
+}
+
+// SetNillableHandle sets the "handle" field if the given value is not nil.
+func (su *SevUpdate) SetNillableHandle(s *string) *SevUpdate {
+	if s != nil {
+		su.SetHandle(*s)
+	}
+	return su
+}
+
+// ClearHandle clears the value of the "handle" field.
+func (su *SevUpdate) ClearHandle() *SevUpdate {
+	su.mutation.ClearHandle()
+	return su
+}
+
+// SetDid sets the "did" field.
+func (su *SevUpdate) SetDid(s string) *SevUpdate {
+	su.mutation.SetDid(s)
+	return su
+}
+
+// SetNillableDid sets the "did" field if the given value is not nil.
+func (su *SevUpdate) SetNillableDid(s *string) *SevUpdate {
+	if s != nil {
+		su.SetDid(*s)
+	}
+	return su
+}
+
+// ClearDid clears the value of the "did" field.
+func (su *SevUpdate) ClearDid() *SevUpdate {
+	su.mutation.ClearDid()
+	return su
+}
+
+// SetUID sets the "uid" field.
+func (su *SevUpdate) SetUID(i int) *SevUpdate {
+	su.mutation.ResetUID()
+	su.mutation.SetUID(i)
+	return su
+}
+
+// SetNillableUID sets the "uid" field if the given value is not nil.
+func (su *SevUpdate) SetNillableUID(i *int) *SevUpdate {
+	if i != nil {
+		su.SetUID(*i)
+	}
+	return su
+}
+
+// AddUID adds i to the "uid" field.
+func (su *SevUpdate) AddUID(i int) *SevUpdate {
+	su.mutation.AddUID(i)
+	return su
+}
+
+// ClearUID clears the value of the "uid" field.
+func (su *SevUpdate) ClearUID() *SevUpdate {
+	su.mutation.ClearUID()
+	return su
+}
+
+// SetCid sets the "cid" field.
+func (su *SevUpdate) SetCid(i int) *SevUpdate {
+	su.mutation.ResetCid()
+	su.mutation.SetCid(i)
+	return su
+}
+
+// SetNillableCid sets the "cid" field if the given value is not nil.
+func (su *SevUpdate) SetNillableCid(i *int) *SevUpdate {
+	if i != nil {
+		su.SetCid(*i)
+	}
+	return su
+}
+
+// AddCid adds i to the "cid" field.
+func (su *SevUpdate) AddCid(i int) *SevUpdate {
+	su.mutation.AddCid(i)
+	return su
+}
+
+// ClearCid clears the value of the "cid" field.
+func (su *SevUpdate) ClearCid() *SevUpdate {
+	su.mutation.ClearCid()
+	return su
+}
+
+// SetCp sets the "cp" field.
+func (su *SevUpdate) SetCp(i int) *SevUpdate {
+	su.mutation.ResetCp()
+	su.mutation.SetCp(i)
+	return su
+}
+
+// SetNillableCp sets the "cp" field if the given value is not nil.
+func (su *SevUpdate) SetNillableCp(i *int) *SevUpdate {
+	if i != nil {
+		su.SetCp(*i)
+	}
+	return su
+}
+
+// AddCp adds i to the "cp" field.
+func (su *SevUpdate) AddCp(i int) *SevUpdate {
+	su.mutation.AddCp(i)
+	return su
+}
+
+// ClearCp clears the value of the "cp" field.
+func (su *SevUpdate) ClearCp() *SevUpdate {
+	su.mutation.ClearCp()
+	return su
+}
+
+// SetCard sets the "card" field.
+func (su *SevUpdate) SetCard(i int) *SevUpdate {
+	su.mutation.ResetCard()
+	su.mutation.SetCard(i)
+	return su
+}
+
+// SetNillableCard sets the "card" field if the given value is not nil.
+func (su *SevUpdate) SetNillableCard(i *int) *SevUpdate {
+	if i != nil {
+		su.SetCard(*i)
+	}
+	return su
+}
+
+// AddCard adds i to the "card" field.
+func (su *SevUpdate) AddCard(i int) *SevUpdate {
+	su.mutation.AddCard(i)
+	return su
+}
+
+// ClearCard clears the value of the "card" field.
+func (su *SevUpdate) ClearCard() *SevUpdate {
+	su.mutation.ClearCard()
+	return su
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (su *SevUpdate) SetUpdatedAt(t time.Time) *SevUpdate {
+	su.mutation.SetUpdatedAt(t)
+	return su
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (su *SevUpdate) SetNillableUpdatedAt(t *time.Time) *SevUpdate {
+	if t != nil {
+		su.SetUpdatedAt(*t)
+	}
+	return su
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (su *SevUpdate) ClearUpdatedAt() *SevUpdate {
+	su.mutation.ClearUpdatedAt()
+	return su
+}
+
+// SetOwnerID sets the "owner" edge to the User entity by ID.
+func (su *SevUpdate) SetOwnerID(id int) *SevUpdate {
+	su.mutation.SetOwnerID(id)
+	return su
+}
+
+// SetOwner sets the "owner" edge to the User entity.
+func (su *SevUpdate) SetOwner(u *User) *SevUpdate {
+	return su.SetOwnerID(u.ID)
+}
+
+// Mutation returns the SevMutation object of the builder.
+func (su *SevUpdate) Mutation() *SevMutation {
+	return su.mutation
+}
+
+// ClearOwner clears the "owner" edge to the User entity.
+func (su *SevUpdate) ClearOwner() *SevUpdate {
+	su.mutation.ClearOwner()
+	return su
+}
+
+// Save executes the query and returns the number of nodes affected by the update operation.
+func (su *SevUpdate) Save(ctx context.Context) (int, error) {
+	return withHooks[int, SevMutation](ctx, su.sqlSave, su.mutation, su.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (su *SevUpdate) SaveX(ctx context.Context) int {
+	affected, err := su.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return affected
+}
+
+// Exec executes the query.
+func (su *SevUpdate) Exec(ctx context.Context) error {
+	_, err := su.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (su *SevUpdate) ExecX(ctx context.Context) {
+	if err := su.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (su *SevUpdate) check() error {
+	if _, ok := su.mutation.OwnerID(); su.mutation.OwnerCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "Sev.owner"`)
+	}
+	return nil
+}
+
+func (su *SevUpdate) sqlSave(ctx context.Context) (n int, err error) {
+	if err := su.check(); err != nil {
+		return n, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt))
+	if ps := su.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := su.mutation.Token(); ok {
+		_spec.SetField(sev.FieldToken, field.TypeString, value)
+	}
+	if su.mutation.TokenCleared() {
+		_spec.ClearField(sev.FieldToken, field.TypeString)
+	}
+	if value, ok := su.mutation.Limit(); ok {
+		_spec.SetField(sev.FieldLimit, field.TypeBool, value)
+	}
+	if su.mutation.LimitCleared() {
+		_spec.ClearField(sev.FieldLimit, field.TypeBool)
+	}
+	if value, ok := su.mutation.Count(); ok {
+		_spec.SetField(sev.FieldCount, field.TypeInt, value)
+	}
+	if value, ok := su.mutation.AddedCount(); ok {
+		_spec.AddField(sev.FieldCount, field.TypeInt, value)
+	}
+	if su.mutation.CountCleared() {
+		_spec.ClearField(sev.FieldCount, field.TypeInt)
+	}
+	if value, ok := su.mutation.Handle(); ok {
+		_spec.SetField(sev.FieldHandle, field.TypeString, value)
+	}
+	if su.mutation.HandleCleared() {
+		_spec.ClearField(sev.FieldHandle, field.TypeString)
+	}
+	if value, ok := su.mutation.Did(); ok {
+		_spec.SetField(sev.FieldDid, field.TypeString, value)
+	}
+	if su.mutation.DidCleared() {
+		_spec.ClearField(sev.FieldDid, field.TypeString)
+	}
+	if value, ok := su.mutation.UID(); ok {
+		_spec.SetField(sev.FieldUID, field.TypeInt, value)
+	}
+	if value, ok := su.mutation.AddedUID(); ok {
+		_spec.AddField(sev.FieldUID, field.TypeInt, value)
+	}
+	if su.mutation.UIDCleared() {
+		_spec.ClearField(sev.FieldUID, field.TypeInt)
+	}
+	if value, ok := su.mutation.Cid(); ok {
+		_spec.SetField(sev.FieldCid, field.TypeInt, value)
+	}
+	if value, ok := su.mutation.AddedCid(); ok {
+		_spec.AddField(sev.FieldCid, field.TypeInt, value)
+	}
+	if su.mutation.CidCleared() {
+		_spec.ClearField(sev.FieldCid, field.TypeInt)
+	}
+	if value, ok := su.mutation.Cp(); ok {
+		_spec.SetField(sev.FieldCp, field.TypeInt, value)
+	}
+	if value, ok := su.mutation.AddedCp(); ok {
+		_spec.AddField(sev.FieldCp, field.TypeInt, value)
+	}
+	if su.mutation.CpCleared() {
+		_spec.ClearField(sev.FieldCp, field.TypeInt)
+	}
+	if value, ok := su.mutation.Card(); ok {
+		_spec.SetField(sev.FieldCard, field.TypeInt, value)
+	}
+	if value, ok := su.mutation.AddedCard(); ok {
+		_spec.AddField(sev.FieldCard, field.TypeInt, value)
+	}
+	if su.mutation.CardCleared() {
+		_spec.ClearField(sev.FieldCard, field.TypeInt)
+	}
+	if value, ok := su.mutation.UpdatedAt(); ok {
+		_spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if su.mutation.UpdatedAtCleared() {
+		_spec.ClearField(sev.FieldUpdatedAt, field.TypeTime)
+	}
+	if su.mutation.CreatedAtCleared() {
+		_spec.ClearField(sev.FieldCreatedAt, field.TypeTime)
+	}
+	if su.mutation.OwnerCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   sev.OwnerTable,
+			Columns: []string{sev.OwnerColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := su.mutation.OwnerIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   sev.OwnerTable,
+			Columns: []string{sev.OwnerColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	if n, err = sqlgraph.UpdateNodes(ctx, su.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{sev.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return 0, err
+	}
+	su.mutation.done = true
+	return n, nil
+}
+
+// SevUpdateOne is the builder for updating a single Sev entity.
+type SevUpdateOne struct {
+	config
+	fields   []string
+	hooks    []Hook
+	mutation *SevMutation
+}
+
+// SetToken sets the "token" field.
+func (suo *SevUpdateOne) SetToken(s string) *SevUpdateOne {
+	suo.mutation.SetToken(s)
+	return suo
+}
+
+// SetNillableToken sets the "token" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableToken(s *string) *SevUpdateOne {
+	if s != nil {
+		suo.SetToken(*s)
+	}
+	return suo
+}
+
+// ClearToken clears the value of the "token" field.
+func (suo *SevUpdateOne) ClearToken() *SevUpdateOne {
+	suo.mutation.ClearToken()
+	return suo
+}
+
+// SetLimit sets the "limit" field.
+func (suo *SevUpdateOne) SetLimit(b bool) *SevUpdateOne {
+	suo.mutation.SetLimit(b)
+	return suo
+}
+
+// SetNillableLimit sets the "limit" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableLimit(b *bool) *SevUpdateOne {
+	if b != nil {
+		suo.SetLimit(*b)
+	}
+	return suo
+}
+
+// ClearLimit clears the value of the "limit" field.
+func (suo *SevUpdateOne) ClearLimit() *SevUpdateOne {
+	suo.mutation.ClearLimit()
+	return suo
+}
+
+// SetCount sets the "count" field.
+func (suo *SevUpdateOne) SetCount(i int) *SevUpdateOne {
+	suo.mutation.ResetCount()
+	suo.mutation.SetCount(i)
+	return suo
+}
+
+// SetNillableCount sets the "count" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableCount(i *int) *SevUpdateOne {
+	if i != nil {
+		suo.SetCount(*i)
+	}
+	return suo
+}
+
+// AddCount adds i to the "count" field.
+func (suo *SevUpdateOne) AddCount(i int) *SevUpdateOne {
+	suo.mutation.AddCount(i)
+	return suo
+}
+
+// ClearCount clears the value of the "count" field.
+func (suo *SevUpdateOne) ClearCount() *SevUpdateOne {
+	suo.mutation.ClearCount()
+	return suo
+}
+
+// SetHandle sets the "handle" field.
+func (suo *SevUpdateOne) SetHandle(s string) *SevUpdateOne {
+	suo.mutation.SetHandle(s)
+	return suo
+}
+
+// SetNillableHandle sets the "handle" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableHandle(s *string) *SevUpdateOne {
+	if s != nil {
+		suo.SetHandle(*s)
+	}
+	return suo
+}
+
+// ClearHandle clears the value of the "handle" field.
+func (suo *SevUpdateOne) ClearHandle() *SevUpdateOne {
+	suo.mutation.ClearHandle()
+	return suo
+}
+
+// SetDid sets the "did" field.
+func (suo *SevUpdateOne) SetDid(s string) *SevUpdateOne {
+	suo.mutation.SetDid(s)
+	return suo
+}
+
+// SetNillableDid sets the "did" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableDid(s *string) *SevUpdateOne {
+	if s != nil {
+		suo.SetDid(*s)
+	}
+	return suo
+}
+
+// ClearDid clears the value of the "did" field.
+func (suo *SevUpdateOne) ClearDid() *SevUpdateOne {
+	suo.mutation.ClearDid()
+	return suo
+}
+
+// SetUID sets the "uid" field.
+func (suo *SevUpdateOne) SetUID(i int) *SevUpdateOne {
+	suo.mutation.ResetUID()
+	suo.mutation.SetUID(i)
+	return suo
+}
+
+// SetNillableUID sets the "uid" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableUID(i *int) *SevUpdateOne {
+	if i != nil {
+		suo.SetUID(*i)
+	}
+	return suo
+}
+
+// AddUID adds i to the "uid" field.
+func (suo *SevUpdateOne) AddUID(i int) *SevUpdateOne {
+	suo.mutation.AddUID(i)
+	return suo
+}
+
+// ClearUID clears the value of the "uid" field.
+func (suo *SevUpdateOne) ClearUID() *SevUpdateOne {
+	suo.mutation.ClearUID()
+	return suo
+}
+
+// SetCid sets the "cid" field.
+func (suo *SevUpdateOne) SetCid(i int) *SevUpdateOne {
+	suo.mutation.ResetCid()
+	suo.mutation.SetCid(i)
+	return suo
+}
+
+// SetNillableCid sets the "cid" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableCid(i *int) *SevUpdateOne {
+	if i != nil {
+		suo.SetCid(*i)
+	}
+	return suo
+}
+
+// AddCid adds i to the "cid" field.
+func (suo *SevUpdateOne) AddCid(i int) *SevUpdateOne {
+	suo.mutation.AddCid(i)
+	return suo
+}
+
+// ClearCid clears the value of the "cid" field.
+func (suo *SevUpdateOne) ClearCid() *SevUpdateOne {
+	suo.mutation.ClearCid()
+	return suo
+}
+
+// SetCp sets the "cp" field.
+func (suo *SevUpdateOne) SetCp(i int) *SevUpdateOne {
+	suo.mutation.ResetCp()
+	suo.mutation.SetCp(i)
+	return suo
+}
+
+// SetNillableCp sets the "cp" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableCp(i *int) *SevUpdateOne {
+	if i != nil {
+		suo.SetCp(*i)
+	}
+	return suo
+}
+
+// AddCp adds i to the "cp" field.
+func (suo *SevUpdateOne) AddCp(i int) *SevUpdateOne {
+	suo.mutation.AddCp(i)
+	return suo
+}
+
+// ClearCp clears the value of the "cp" field.
+func (suo *SevUpdateOne) ClearCp() *SevUpdateOne {
+	suo.mutation.ClearCp()
+	return suo
+}
+
+// SetCard sets the "card" field.
+func (suo *SevUpdateOne) SetCard(i int) *SevUpdateOne {
+	suo.mutation.ResetCard()
+	suo.mutation.SetCard(i)
+	return suo
+}
+
+// SetNillableCard sets the "card" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableCard(i *int) *SevUpdateOne {
+	if i != nil {
+		suo.SetCard(*i)
+	}
+	return suo
+}
+
+// AddCard adds i to the "card" field.
+func (suo *SevUpdateOne) AddCard(i int) *SevUpdateOne {
+	suo.mutation.AddCard(i)
+	return suo
+}
+
+// ClearCard clears the value of the "card" field.
+func (suo *SevUpdateOne) ClearCard() *SevUpdateOne {
+	suo.mutation.ClearCard()
+	return suo
+}
+
+// SetUpdatedAt sets the "updated_at" field.
+func (suo *SevUpdateOne) SetUpdatedAt(t time.Time) *SevUpdateOne {
+	suo.mutation.SetUpdatedAt(t)
+	return suo
+}
+
+// SetNillableUpdatedAt sets the "updated_at" field if the given value is not nil.
+func (suo *SevUpdateOne) SetNillableUpdatedAt(t *time.Time) *SevUpdateOne {
+	if t != nil {
+		suo.SetUpdatedAt(*t)
+	}
+	return suo
+}
+
+// ClearUpdatedAt clears the value of the "updated_at" field.
+func (suo *SevUpdateOne) ClearUpdatedAt() *SevUpdateOne {
+	suo.mutation.ClearUpdatedAt()
+	return suo
+}
+
+// SetOwnerID sets the "owner" edge to the User entity by ID.
+func (suo *SevUpdateOne) SetOwnerID(id int) *SevUpdateOne {
+	suo.mutation.SetOwnerID(id)
+	return suo
+}
+
+// SetOwner sets the "owner" edge to the User entity.
+func (suo *SevUpdateOne) SetOwner(u *User) *SevUpdateOne {
+	return suo.SetOwnerID(u.ID)
+}
+
+// Mutation returns the SevMutation object of the builder.
+func (suo *SevUpdateOne) Mutation() *SevMutation {
+	return suo.mutation
+}
+
+// ClearOwner clears the "owner" edge to the User entity.
+func (suo *SevUpdateOne) ClearOwner() *SevUpdateOne {
+	suo.mutation.ClearOwner()
+	return suo
+}
+
+// Where appends a list predicates to the SevUpdate builder.
+func (suo *SevUpdateOne) Where(ps ...predicate.Sev) *SevUpdateOne {
+	suo.mutation.Where(ps...)
+	return suo
+}
+
+// Select allows selecting one or more fields (columns) of the returned entity.
+// The default is selecting all fields defined in the entity schema.
+func (suo *SevUpdateOne) Select(field string, fields ...string) *SevUpdateOne {
+	suo.fields = append([]string{field}, fields...)
+	return suo
+}
+
+// Save executes the query and returns the updated Sev entity.
+func (suo *SevUpdateOne) Save(ctx context.Context) (*Sev, error) {
+	return withHooks[*Sev, SevMutation](ctx, suo.sqlSave, suo.mutation, suo.hooks)
+}
+
+// SaveX is like Save, but panics if an error occurs.
+func (suo *SevUpdateOne) SaveX(ctx context.Context) *Sev {
+	node, err := suo.Save(ctx)
+	if err != nil {
+		panic(err)
+	}
+	return node
+}
+
+// Exec executes the query on the entity.
+func (suo *SevUpdateOne) Exec(ctx context.Context) error {
+	_, err := suo.Save(ctx)
+	return err
+}
+
+// ExecX is like Exec, but panics if an error occurs.
+func (suo *SevUpdateOne) ExecX(ctx context.Context) {
+	if err := suo.Exec(ctx); err != nil {
+		panic(err)
+	}
+}
+
+// check runs all checks and user-defined validators on the builder.
+func (suo *SevUpdateOne) check() error {
+	if _, ok := suo.mutation.OwnerID(); suo.mutation.OwnerCleared() && !ok {
+		return errors.New(`ent: clearing a required unique edge "Sev.owner"`)
+	}
+	return nil
+}
+
+func (suo *SevUpdateOne) sqlSave(ctx context.Context) (_node *Sev, err error) {
+	if err := suo.check(); err != nil {
+		return _node, err
+	}
+	_spec := sqlgraph.NewUpdateSpec(sev.Table, sev.Columns, sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt))
+	id, ok := suo.mutation.ID()
+	if !ok {
+		return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Sev.id" for update`)}
+	}
+	_spec.Node.ID.Value = id
+	if fields := suo.fields; len(fields) > 0 {
+		_spec.Node.Columns = make([]string, 0, len(fields))
+		_spec.Node.Columns = append(_spec.Node.Columns, sev.FieldID)
+		for _, f := range fields {
+			if !sev.ValidColumn(f) {
+				return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
+			}
+			if f != sev.FieldID {
+				_spec.Node.Columns = append(_spec.Node.Columns, f)
+			}
+		}
+	}
+	if ps := suo.mutation.predicates; len(ps) > 0 {
+		_spec.Predicate = func(selector *sql.Selector) {
+			for i := range ps {
+				ps[i](selector)
+			}
+		}
+	}
+	if value, ok := suo.mutation.Token(); ok {
+		_spec.SetField(sev.FieldToken, field.TypeString, value)
+	}
+	if suo.mutation.TokenCleared() {
+		_spec.ClearField(sev.FieldToken, field.TypeString)
+	}
+	if value, ok := suo.mutation.Limit(); ok {
+		_spec.SetField(sev.FieldLimit, field.TypeBool, value)
+	}
+	if suo.mutation.LimitCleared() {
+		_spec.ClearField(sev.FieldLimit, field.TypeBool)
+	}
+	if value, ok := suo.mutation.Count(); ok {
+		_spec.SetField(sev.FieldCount, field.TypeInt, value)
+	}
+	if value, ok := suo.mutation.AddedCount(); ok {
+		_spec.AddField(sev.FieldCount, field.TypeInt, value)
+	}
+	if suo.mutation.CountCleared() {
+		_spec.ClearField(sev.FieldCount, field.TypeInt)
+	}
+	if value, ok := suo.mutation.Handle(); ok {
+		_spec.SetField(sev.FieldHandle, field.TypeString, value)
+	}
+	if suo.mutation.HandleCleared() {
+		_spec.ClearField(sev.FieldHandle, field.TypeString)
+	}
+	if value, ok := suo.mutation.Did(); ok {
+		_spec.SetField(sev.FieldDid, field.TypeString, value)
+	}
+	if suo.mutation.DidCleared() {
+		_spec.ClearField(sev.FieldDid, field.TypeString)
+	}
+	if value, ok := suo.mutation.UID(); ok {
+		_spec.SetField(sev.FieldUID, field.TypeInt, value)
+	}
+	if value, ok := suo.mutation.AddedUID(); ok {
+		_spec.AddField(sev.FieldUID, field.TypeInt, value)
+	}
+	if suo.mutation.UIDCleared() {
+		_spec.ClearField(sev.FieldUID, field.TypeInt)
+	}
+	if value, ok := suo.mutation.Cid(); ok {
+		_spec.SetField(sev.FieldCid, field.TypeInt, value)
+	}
+	if value, ok := suo.mutation.AddedCid(); ok {
+		_spec.AddField(sev.FieldCid, field.TypeInt, value)
+	}
+	if suo.mutation.CidCleared() {
+		_spec.ClearField(sev.FieldCid, field.TypeInt)
+	}
+	if value, ok := suo.mutation.Cp(); ok {
+		_spec.SetField(sev.FieldCp, field.TypeInt, value)
+	}
+	if value, ok := suo.mutation.AddedCp(); ok {
+		_spec.AddField(sev.FieldCp, field.TypeInt, value)
+	}
+	if suo.mutation.CpCleared() {
+		_spec.ClearField(sev.FieldCp, field.TypeInt)
+	}
+	if value, ok := suo.mutation.Card(); ok {
+		_spec.SetField(sev.FieldCard, field.TypeInt, value)
+	}
+	if value, ok := suo.mutation.AddedCard(); ok {
+		_spec.AddField(sev.FieldCard, field.TypeInt, value)
+	}
+	if suo.mutation.CardCleared() {
+		_spec.ClearField(sev.FieldCard, field.TypeInt)
+	}
+	if value, ok := suo.mutation.UpdatedAt(); ok {
+		_spec.SetField(sev.FieldUpdatedAt, field.TypeTime, value)
+	}
+	if suo.mutation.UpdatedAtCleared() {
+		_spec.ClearField(sev.FieldUpdatedAt, field.TypeTime)
+	}
+	if suo.mutation.CreatedAtCleared() {
+		_spec.ClearField(sev.FieldCreatedAt, field.TypeTime)
+	}
+	if suo.mutation.OwnerCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   sev.OwnerTable,
+			Columns: []string{sev.OwnerColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := suo.mutation.OwnerIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.M2O,
+			Inverse: true,
+			Table:   sev.OwnerTable,
+			Columns: []string{sev.OwnerColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(user.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
+	_node = &Sev{config: suo.config}
+	_spec.Assign = _node.assignValues
+	_spec.ScanValues = _node.scanValues
+	if err = sqlgraph.UpdateNode(ctx, suo.driver, _spec); err != nil {
+		if _, ok := err.(*sqlgraph.NotFoundError); ok {
+			err = &NotFoundError{sev.Label}
+		} else if sqlgraph.IsConstraintError(err) {
+			err = &ConstraintError{msg: err.Error(), wrap: err}
+		}
+		return nil, err
+	}
+	suo.mutation.done = true
+	return _node, nil
+}

ent/tx.go

@@ -18,6 +18,8 @@ type Tx struct {
 	Group *GroupClient
 	// Ma is the client for interacting with the Ma builders.
 	Ma *MaClient
+	// Sev is the client for interacting with the Sev builders.
+	Sev *SevClient
 	// Ue is the client for interacting with the Ue builders.
 	Ue *UeClient
 	// User is the client for interacting with the User builders.
@@ -156,6 +158,7 @@ func (tx *Tx) init() {
 	tx.Card = NewCardClient(tx.config)
 	tx.Group = NewGroupClient(tx.config)
 	tx.Ma = NewMaClient(tx.config)
+	tx.Sev = NewSevClient(tx.config)
 	tx.Ue = NewUeClient(tx.config)
 	tx.User = NewUserClient(tx.config)
 }

ent/user.go

@@ -132,9 +132,11 @@ type UserEdges struct {
 	Ue []*Ue `json:"ue,omitempty"`
 	// Ma holds the value of the ma edge.
 	Ma []*Ma `json:"ma,omitempty"`
+	// Sev holds the value of the sev edge.
+	Sev []*Sev `json:"sev,omitempty"`
 	// loadedTypes holds the information for reporting if a
 	// type was loaded (or requested) in eager-loading or not.
-	loadedTypes [3]bool
+	loadedTypes [4]bool
 }
 
 // CardOrErr returns the Card value or an error if the edge
@@ -164,6 +166,15 @@ func (e UserEdges) MaOrErr() ([]*Ma, error) {
 	return nil, &NotLoadedError{edge: "ma"}
 }
 
+// SevOrErr returns the Sev value or an error if the edge
+// was not loaded in eager-loading.
+func (e UserEdges) SevOrErr() ([]*Sev, error) {
+	if e.loadedTypes[3] {
+		return e.Sev, nil
+	}
+	return nil, &NotLoadedError{edge: "sev"}
+}
+
 // scanValues returns the types for scanning values from sql.Rows.
 func (*User) scanValues(columns []string) ([]any, error) {
 	values := make([]any, len(columns))
@@ -535,6 +546,11 @@ func (u *User) QueryMa() *MaQuery {
 	return NewUserClient(u.config).QueryMa(u)
 }
 
+// QuerySev queries the "sev" edge of the User entity.
+func (u *User) QuerySev() *SevQuery {
+	return NewUserClient(u.config).QuerySev(u)
+}
+
 // Update returns a builder for updating this User.
 // Note that you need to call User.Unwrap() before calling this method if this User
 // was returned from a transaction, and the transaction was committed or rolled back.

ent/user/user.go

@@ -120,6 +120,8 @@ const (
 	EdgeUe = "ue"
 	// EdgeMa holds the string denoting the ma edge name in mutations.
 	EdgeMa = "ma"
+	// EdgeSev holds the string denoting the sev edge name in mutations.
+	EdgeSev = "sev"
 	// Table holds the table name of the user in the database.
 	Table = "users"
 	// CardTable is the table that holds the card relation/edge.
@@ -143,6 +145,13 @@ const (
 	MaInverseTable = "mas"
 	// MaColumn is the table column denoting the ma relation/edge.
 	MaColumn = "user_ma"
+	// SevTable is the table that holds the sev relation/edge.
+	SevTable = "sevs"
+	// SevInverseTable is the table name for the Sev entity.
+	// It exists in this package in order to avoid circular dependency with the "sev" package.
+	SevInverseTable = "sevs"
+	// SevColumn is the table column denoting the sev relation/edge.
+	SevColumn = "user_sev"
 )
 
 // Columns holds all SQL columns for user fields.
@@ -575,6 +584,20 @@ func ByMa(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
 		sqlgraph.OrderByNeighborTerms(s, newMaStep(), append([]sql.OrderTerm{term}, terms...)...)
 	}
 }
+
+// BySevCount orders the results by sev count.
+func BySevCount(opts ...sql.OrderTermOption) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborsCount(s, newSevStep(), opts...)
+	}
+}
+
+// BySev orders the results by sev terms.
+func BySev(term sql.OrderTerm, terms ...sql.OrderTerm) OrderOption {
+	return func(s *sql.Selector) {
+		sqlgraph.OrderByNeighborTerms(s, newSevStep(), append([]sql.OrderTerm{term}, terms...)...)
+	}
+}
 func newCardStep() *sqlgraph.Step {
 	return sqlgraph.NewStep(
 		sqlgraph.From(Table, FieldID),
@@ -596,3 +619,10 @@ func newMaStep() *sqlgraph.Step {
 		sqlgraph.Edge(sqlgraph.O2M, false, MaTable, MaColumn),
 	)
 }
+func newSevStep() *sqlgraph.Step {
+	return sqlgraph.NewStep(
+		sqlgraph.From(Table, FieldID),
+		sqlgraph.To(SevInverseTable, FieldID),
+		sqlgraph.Edge(sqlgraph.O2M, false, SevTable, SevColumn),
+	)
+}

ent/user/where.go

@@ -2629,6 +2629,29 @@ func HasMaWith(preds ...predicate.Ma) predicate.User {
 	})
 }
 
+// HasSev applies the HasEdge predicate on the "sev" edge.
+func HasSev() predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := sqlgraph.NewStep(
+			sqlgraph.From(Table, FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, SevTable, SevColumn),
+		)
+		sqlgraph.HasNeighbors(s, step)
+	})
+}
+
+// HasSevWith applies the HasEdge predicate on the "sev" edge with a given conditions (other predicates).
+func HasSevWith(preds ...predicate.Sev) predicate.User {
+	return predicate.User(func(s *sql.Selector) {
+		step := newSevStep()
+		sqlgraph.HasNeighborsWith(s, step, func(s *sql.Selector) {
+			for _, p := range preds {
+				p(s)
+			}
+		})
+	})
+}
+
 // And groups predicates with the AND operator between them.
 func And(predicates ...predicate.User) predicate.User {
 	return predicate.User(func(s *sql.Selector) {

ent/user_create.go

@@ -5,6 +5,7 @@ package ent
 import (
 	"api/ent/card"
 	"api/ent/ma"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 	"context"
@@ -752,6 +753,21 @@ func (uc *UserCreate) AddMa(m ...*Ma) *UserCreate {
 	return uc.AddMaIDs(ids...)
 }
 
+// AddSevIDs adds the "sev" edge to the Sev entity by IDs.
+func (uc *UserCreate) AddSevIDs(ids ...int) *UserCreate {
+	uc.mutation.AddSevIDs(ids...)
+	return uc
+}
+
+// AddSev adds the "sev" edges to the Sev entity.
+func (uc *UserCreate) AddSev(s ...*Sev) *UserCreate {
+	ids := make([]int, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uc.AddSevIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uc *UserCreate) Mutation() *UserMutation {
 	return uc.mutation
@@ -1177,6 +1193,22 @@ func (uc *UserCreate) createSpec() (*User, *sqlgraph.CreateSpec) {
 		}
 		_spec.Edges = append(_spec.Edges, edge)
 	}
+	if nodes := uc.mutation.SevIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges = append(_spec.Edges, edge)
+	}
 	return _node, _spec
 }
 

ent/user_query.go

@@ -6,6 +6,7 @@ import (
 	"api/ent/card"
 	"api/ent/ma"
 	"api/ent/predicate"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 	"context"
@@ -28,6 +29,7 @@ type UserQuery struct {
 	withCard   *CardQuery
 	withUe     *UeQuery
 	withMa     *MaQuery
+	withSev    *SevQuery
 	withFKs    bool
 	// intermediate query (i.e. traversal path).
 	sql  *sql.Selector
@@ -131,6 +133,28 @@ func (uq *UserQuery) QueryMa() *MaQuery {
 	return query
 }
 
+// QuerySev chains the current query on the "sev" edge.
+func (uq *UserQuery) QuerySev() *SevQuery {
+	query := (&SevClient{config: uq.config}).Query()
+	query.path = func(ctx context.Context) (fromU *sql.Selector, err error) {
+		if err := uq.prepareQuery(ctx); err != nil {
+			return nil, err
+		}
+		selector := uq.sqlQuery(ctx)
+		if err := selector.Err(); err != nil {
+			return nil, err
+		}
+		step := sqlgraph.NewStep(
+			sqlgraph.From(user.Table, user.FieldID, selector),
+			sqlgraph.To(sev.Table, sev.FieldID),
+			sqlgraph.Edge(sqlgraph.O2M, false, user.SevTable, user.SevColumn),
+		)
+		fromU = sqlgraph.SetNeighbors(uq.driver.Dialect(), step)
+		return fromU, nil
+	}
+	return query
+}
+
 // First returns the first User entity from the query.
 // Returns a *NotFoundError when no User was found.
 func (uq *UserQuery) First(ctx context.Context) (*User, error) {
@@ -326,6 +350,7 @@ func (uq *UserQuery) Clone() *UserQuery {
 		withCard:   uq.withCard.Clone(),
 		withUe:     uq.withUe.Clone(),
 		withMa:     uq.withMa.Clone(),
+		withSev:    uq.withSev.Clone(),
 		// clone intermediate query.
 		sql:  uq.sql.Clone(),
 		path: uq.path,
@@ -365,6 +390,17 @@ func (uq *UserQuery) WithMa(opts ...func(*MaQuery)) *UserQuery {
 	return uq
 }
 
+// WithSev tells the query-builder to eager-load the nodes that are connected to
+// the "sev" edge. The optional arguments are used to configure the query builder of the edge.
+func (uq *UserQuery) WithSev(opts ...func(*SevQuery)) *UserQuery {
+	query := (&SevClient{config: uq.config}).Query()
+	for _, opt := range opts {
+		opt(query)
+	}
+	uq.withSev = query
+	return uq
+}
+
 // GroupBy is used to group vertices by one or more fields/columns.
 // It is often used with aggregate functions, like: count, max, mean, min, sum.
 //
@@ -444,10 +480,11 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 		nodes       = []*User{}
 		withFKs     = uq.withFKs
 		_spec       = uq.querySpec()
-		loadedTypes = [3]bool{
+		loadedTypes = [4]bool{
 			uq.withCard != nil,
 			uq.withUe != nil,
 			uq.withMa != nil,
+			uq.withSev != nil,
 		}
 	)
 	if withFKs {
@@ -492,6 +529,13 @@ func (uq *UserQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*User, e
 			return nil, err
 		}
 	}
+	if query := uq.withSev; query != nil {
+		if err := uq.loadSev(ctx, query, nodes,
+			func(n *User) { n.Edges.Sev = []*Sev{} },
+			func(n *User, e *Sev) { n.Edges.Sev = append(n.Edges.Sev, e) }); err != nil {
+			return nil, err
+		}
+	}
 	return nodes, nil
 }
 
@@ -588,6 +632,37 @@ func (uq *UserQuery) loadMa(ctx context.Context, query *MaQuery, nodes []*User,
 	}
 	return nil
 }
+func (uq *UserQuery) loadSev(ctx context.Context, query *SevQuery, nodes []*User, init func(*User), assign func(*User, *Sev)) error {
+	fks := make([]driver.Value, 0, len(nodes))
+	nodeids := make(map[int]*User)
+	for i := range nodes {
+		fks = append(fks, nodes[i].ID)
+		nodeids[nodes[i].ID] = nodes[i]
+		if init != nil {
+			init(nodes[i])
+		}
+	}
+	query.withFKs = true
+	query.Where(predicate.Sev(func(s *sql.Selector) {
+		s.Where(sql.InValues(s.C(user.SevColumn), fks...))
+	}))
+	neighbors, err := query.All(ctx)
+	if err != nil {
+		return err
+	}
+	for _, n := range neighbors {
+		fk := n.user_sev
+		if fk == nil {
+			return fmt.Errorf(`foreign-key "user_sev" is nil for node %v`, n.ID)
+		}
+		node, ok := nodeids[*fk]
+		if !ok {
+			return fmt.Errorf(`unexpected referenced foreign-key "user_sev" returned %v for node %v`, *fk, n.ID)
+		}
+		assign(node, n)
+	}
+	return nil
+}
 
 func (uq *UserQuery) sqlCount(ctx context.Context) (int, error) {
 	_spec := uq.querySpec()

ent/user_update.go

@@ -6,6 +6,7 @@ import (
 	"api/ent/card"
 	"api/ent/ma"
 	"api/ent/predicate"
+	"api/ent/sev"
 	"api/ent/ue"
 	"api/ent/user"
 	"context"
@@ -1128,6 +1129,21 @@ func (uu *UserUpdate) AddMa(m ...*Ma) *UserUpdate {
 	return uu.AddMaIDs(ids...)
 }
 
+// AddSevIDs adds the "sev" edge to the Sev entity by IDs.
+func (uu *UserUpdate) AddSevIDs(ids ...int) *UserUpdate {
+	uu.mutation.AddSevIDs(ids...)
+	return uu
+}
+
+// AddSev adds the "sev" edges to the Sev entity.
+func (uu *UserUpdate) AddSev(s ...*Sev) *UserUpdate {
+	ids := make([]int, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uu.AddSevIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uu *UserUpdate) Mutation() *UserMutation {
 	return uu.mutation
@@ -1196,6 +1212,27 @@ func (uu *UserUpdate) RemoveMa(m ...*Ma) *UserUpdate {
 	return uu.RemoveMaIDs(ids...)
 }
 
+// ClearSev clears all "sev" edges to the Sev entity.
+func (uu *UserUpdate) ClearSev() *UserUpdate {
+	uu.mutation.ClearSev()
+	return uu
+}
+
+// RemoveSevIDs removes the "sev" edge to Sev entities by IDs.
+func (uu *UserUpdate) RemoveSevIDs(ids ...int) *UserUpdate {
+	uu.mutation.RemoveSevIDs(ids...)
+	return uu
+}
+
+// RemoveSev removes "sev" edges to Sev entities.
+func (uu *UserUpdate) RemoveSev(s ...*Sev) *UserUpdate {
+	ids := make([]int, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uu.RemoveSevIDs(ids...)
+}
+
 // Save executes the query and returns the number of nodes affected by the update operation.
 func (uu *UserUpdate) Save(ctx context.Context) (int, error) {
 	return withHooks[int, UserMutation](ctx, uu.sqlSave, uu.mutation, uu.hooks)
@@ -1700,6 +1737,51 @@ func (uu *UserUpdate) sqlSave(ctx context.Context) (n int, err error) {
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if uu.mutation.SevCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.RemovedSevIDs(); len(nodes) > 0 && !uu.mutation.SevCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uu.mutation.SevIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	if n, err = sqlgraph.UpdateNodes(ctx, uu.driver, _spec); err != nil {
 		if _, ok := err.(*sqlgraph.NotFoundError); ok {
 			err = &NotFoundError{user.Label}
@@ -2817,6 +2899,21 @@ func (uuo *UserUpdateOne) AddMa(m ...*Ma) *UserUpdateOne {
 	return uuo.AddMaIDs(ids...)
 }
 
+// AddSevIDs adds the "sev" edge to the Sev entity by IDs.
+func (uuo *UserUpdateOne) AddSevIDs(ids ...int) *UserUpdateOne {
+	uuo.mutation.AddSevIDs(ids...)
+	return uuo
+}
+
+// AddSev adds the "sev" edges to the Sev entity.
+func (uuo *UserUpdateOne) AddSev(s ...*Sev) *UserUpdateOne {
+	ids := make([]int, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uuo.AddSevIDs(ids...)
+}
+
 // Mutation returns the UserMutation object of the builder.
 func (uuo *UserUpdateOne) Mutation() *UserMutation {
 	return uuo.mutation
@@ -2885,6 +2982,27 @@ func (uuo *UserUpdateOne) RemoveMa(m ...*Ma) *UserUpdateOne {
 	return uuo.RemoveMaIDs(ids...)
 }
 
+// ClearSev clears all "sev" edges to the Sev entity.
+func (uuo *UserUpdateOne) ClearSev() *UserUpdateOne {
+	uuo.mutation.ClearSev()
+	return uuo
+}
+
+// RemoveSevIDs removes the "sev" edge to Sev entities by IDs.
+func (uuo *UserUpdateOne) RemoveSevIDs(ids ...int) *UserUpdateOne {
+	uuo.mutation.RemoveSevIDs(ids...)
+	return uuo
+}
+
+// RemoveSev removes "sev" edges to Sev entities.
+func (uuo *UserUpdateOne) RemoveSev(s ...*Sev) *UserUpdateOne {
+	ids := make([]int, len(s))
+	for i := range s {
+		ids[i] = s[i].ID
+	}
+	return uuo.RemoveSevIDs(ids...)
+}
+
 // Where appends a list predicates to the UserUpdate builder.
 func (uuo *UserUpdateOne) Where(ps ...predicate.User) *UserUpdateOne {
 	uuo.mutation.Where(ps...)
@@ -3419,6 +3537,51 @@ func (uuo *UserUpdateOne) sqlSave(ctx context.Context) (_node *User, err error)
 		}
 		_spec.Edges.Add = append(_spec.Edges.Add, edge)
 	}
+	if uuo.mutation.SevCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.RemovedSevIDs(); len(nodes) > 0 && !uuo.mutation.SevCleared() {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Clear = append(_spec.Edges.Clear, edge)
+	}
+	if nodes := uuo.mutation.SevIDs(); len(nodes) > 0 {
+		edge := &sqlgraph.EdgeSpec{
+			Rel:     sqlgraph.O2M,
+			Inverse: false,
+			Table:   user.SevTable,
+			Columns: []string{user.SevColumn},
+			Bidi:    false,
+			Target: &sqlgraph.EdgeTarget{
+				IDSpec: sqlgraph.NewFieldSpec(sev.FieldID, field.TypeInt),
+			},
+		}
+		for _, k := range nodes {
+			edge.Target.Nodes = append(edge.Target.Nodes, k)
+		}
+		_spec.Edges.Add = append(_spec.Edges.Add, edge)
+	}
 	_node = &User{config: uuo.config}
 	_spec.Assign = _node.assignValues
 	_spec.ScanValues = _node.scanValues

tmp/ogent/oas_response_encoders_gen.go

@@ -176,6 +176,61 @@ func encodeCreateMaResponse(response CreateMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeCreateSevResponse(response CreateSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *SevCreate:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeCreateUeResponse(response CreateUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeCreate:
@@ -469,6 +524,67 @@ func encodeDeleteMaResponse(response DeleteMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeDeleteSevResponse(response DeleteSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *DeleteSevNoContent:
+		w.WriteHeader(204)
+		span.SetStatus(codes.Ok, http.StatusText(204))
+
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeDeleteUeResponse(response DeleteUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *DeleteUeNoContent:
@@ -875,6 +991,74 @@ func encodeListMaResponse(response ListMaRes, w http.ResponseWriter, span trace.
 	}
 }
 
+func encodeListSevResponse(response ListSevRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *ListSevOKApplicationJSON:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeListUeResponse(response ListUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *ListUeOKApplicationJSON:
@@ -1146,6 +1330,73 @@ func encodeListUserMaResponse(response ListUserMaRes, w http.ResponseWriter, spa
 	}
 }
 
+func encodeListUserSevResponse(response ListUserSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *ListUserSevOKApplicationJSON:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeListUserUeResponse(response ListUserUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *ListUserUeOKApplicationJSON:
@@ -1485,6 +1736,7 @@ func encodeReadMaResponse(response ReadMaRes, w http.ResponseWriter, span trace.
 }
 
 func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://manga.syui.ai")
 	switch response := response.(type) {
 	case *MaOwnerRead:
 		w.Header().Set("Content-Type", "application/json")
@@ -1551,6 +1803,142 @@ func encodeReadMaOwnerResponse(response ReadMaOwnerRes, w http.ResponseWriter, s
 	}
 }
 
+func encodeReadSevResponse(response ReadSevRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *SevRead:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
+func encodeReadSevOwnerResponse(response ReadSevOwnerRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
+	switch response := response.(type) {
+	case *SevOwnerRead:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeReadUeResponse(response ReadUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeRead:
@@ -1686,6 +2074,7 @@ func encodeReadUeOwnerResponse(response ReadUeOwnerRes, w http.ResponseWriter, s
 }
 
 func encodeReadUserResponse(response ReadUserRes, w http.ResponseWriter, span trace.Span) error {
+	w.Header().Set("Access-Control-Allow-Origin", "https://card.syui.ai")
 	switch response := response.(type) {
 	case *UserRead:
 		w.Header().Set("Content-Type", "application/json")
@@ -1953,6 +2342,73 @@ func encodeUpdateMaResponse(response UpdateMaRes, w http.ResponseWriter, span tr
 	}
 }
 
+func encodeUpdateSevResponse(response UpdateSevRes, w http.ResponseWriter, span trace.Span) error {
+	switch response := response.(type) {
+	case *SevUpdate:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(200)
+		span.SetStatus(codes.Ok, http.StatusText(200))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R400:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(400)
+		span.SetStatus(codes.Error, http.StatusText(400))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R404:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(404)
+		span.SetStatus(codes.Error, http.StatusText(404))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R409:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(409)
+		span.SetStatus(codes.Error, http.StatusText(409))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	case *R500:
+		w.Header().Set("Content-Type", "application/json")
+		w.WriteHeader(500)
+		span.SetStatus(codes.Error, http.StatusText(500))
+
+		e := jx.GetEncoder()
+		response.Encode(e)
+		if _, err := e.WriteTo(w); err != nil {
+			return errors.Wrap(err, "write")
+		}
+		return nil
+
+	default:
+		return errors.Errorf("unexpected response type: %T", response)
+	}
+}
+
 func encodeUpdateUeResponse(response UpdateUeRes, w http.ResponseWriter, span trace.Span) error {
 	switch response := response.(type) {
 	case *UeUpdate:

tmp/ogent/ogent.go

@@ -11,6 +11,7 @@ import (
 	"api/ent/group"
 	"api/ent/ma"
 	"api/ent/ue"
+	"api/ent/sev"
 	"api/ent/user"
 
 	"os"
@@ -781,6 +782,276 @@ func (h *OgentHandler) ReadMaOwner(ctx context.Context, params ReadMaOwnerParams
 	return NewMaOwnerRead(e), nil
 }
 
+// CreateSev handles POST /sevs requests.
+func (h *OgentHandler) CreateSev(ctx context.Context, req *CreateSevReq) (CreateSevRes, error) {
+	b := h.client.Sev.Create()
+	// Add all fields.
+	b.SetPassword(req.Password)
+	if v, ok := req.Token.Get(); ok {
+		b.SetToken(v)
+	}
+	if v, ok := req.Limit.Get(); ok {
+		b.SetLimit(v)
+	}
+	if v, ok := req.Count.Get(); ok {
+		b.SetCount(v)
+	}
+	if v, ok := req.Handle.Get(); ok {
+		b.SetHandle(v)
+	}
+	if v, ok := req.Did.Get(); ok {
+		b.SetDid(v)
+	}
+	if v, ok := req.UID.Get(); ok {
+		b.SetUID(v)
+	}
+	if v, ok := req.Cid.Get(); ok {
+		b.SetCid(v)
+	}
+	if v, ok := req.Card.Get(); ok {
+		b.SetCard(v)
+	}
+	if v, ok := req.Cp.Get(); ok {
+		b.SetCp(v)
+	}
+	if v, ok := req.UpdatedAt.Get(); ok {
+		b.SetUpdatedAt(v)
+	}
+	if v, ok := req.CreatedAt.Get(); ok {
+		b.SetCreatedAt(v)
+	}
+
+	// Add all edges.
+	//b.SetOwnerID(req.Owner)
+	if req.Password == password {
+		b.SetOwnerID(req.Owner)
+	} else {
+		b.SetOwnerID(0)
+	}
+	// Persist to storage.
+	e, err := b.Save(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	// Reload the entity to attach all eager-loaded edges.
+	q := h.client.Sev.Query().Where(sev.ID(e.ID))
+	e, err = q.Only(ctx)
+	if err != nil {
+		// This should never happen.
+		return nil, err
+	}
+	return NewSevCreate(e), nil
+}
+
+// ReadSev handles GET /sevs/{id} requests.
+func (h *OgentHandler) ReadSev(ctx context.Context, params ReadSevParams) (ReadSevRes, error) {
+	q := h.client.Sev.Query().Where(sev.IDEQ(params.ID))
+	e, err := q.Only(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return NewSevRead(e), nil
+}
+
+// UpdateSev handles PATCH /sevs/{id} requests.
+func (h *OgentHandler) UpdateSev(ctx context.Context, req *UpdateSevReq, params UpdateSevParams) (UpdateSevRes, error) {
+	b := h.client.Sev.UpdateOneID(params.ID)
+	// Add all fields.
+	if v, ok := req.Token.Get(); ok {
+		b.SetToken(v)
+	}
+	if v, ok := req.Limit.Get(); ok {
+		b.SetLimit(v)
+	}
+	if v, ok := req.Count.Get(); ok {
+		b.SetCount(v)
+	}
+	if v, ok := req.Handle.Get(); ok {
+		b.SetHandle(v)
+	}
+	if v, ok := req.Did.Get(); ok {
+		b.SetDid(v)
+	}
+	if v, ok := req.UID.Get(); ok {
+		b.SetUID(v)
+	}
+	if v, ok := req.Cid.Get(); ok {
+		b.SetCid(v)
+	}
+	if v, ok := req.Card.Get(); ok {
+		b.SetCard(v)
+	}
+	if v, ok := req.Cp.Get(); ok {
+		b.SetCp(v)
+	}
+	if v, ok := req.UpdatedAt.Get(); ok {
+		b.SetUpdatedAt(v)
+	}
+	// Add all edges.
+	//if v, ok := req.Owner.Get(); ok {
+	//	b.SetOwnerID(v)
+	//}
+	if v, ok := req.Token.Get(); ok {
+		if v == token {
+			b.SetToken(v)
+			if v, ok := req.Owner.Get(); ok {
+				b.SetOwnerID(v)
+			}
+		}
+	}
+	// Persist to storage.
+	e, err := b.Save(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	// Reload the entity to attach all eager-loaded edges.
+	q := h.client.Sev.Query().Where(sev.ID(e.ID))
+	e, err = q.Only(ctx)
+	if err != nil {
+		// This should never happen.
+		return nil, err
+	}
+	return NewSevUpdate(e), nil
+}
+
+// DeleteSev handles DELETE /sevs/{id} requests.
+func (h *OgentHandler) DeleteSev(ctx context.Context, params DeleteSevParams) (DeleteSevRes, error) {
+	//err := h.client.Sev.DeleteOneID(params.ID).Exec(ctx)
+	err := h.client.Sev.DeleteOneID(0).Exec(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsConstraintError(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return new(DeleteSevNoContent), nil
+
+}
+
+// ListSev handles GET /sevs requests.
+func (h *OgentHandler) ListSev(ctx context.Context, params ListSevParams) (ListSevRes, error) {
+	q := h.client.Sev.Query()
+	page := 1
+	if v, ok := params.Page.Get(); ok {
+		page = v
+	}
+	itemsPerPage := 30
+	if v, ok := params.ItemsPerPage.Get(); ok {
+		itemsPerPage = v
+	}
+	q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
+
+	es, err := q.All(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	r := NewSevLists(es)
+	return (*ListSevOKApplicationJSON)(&r), nil
+}
+
+// ReadSevOwner handles GET /sevs/{id}/owner requests.
+func (h *OgentHandler) ReadSevOwner(ctx context.Context, params ReadSevOwnerParams) (ReadSevOwnerRes, error) {
+	q := h.client.Sev.Query().Where(sev.IDEQ(params.ID)).QueryOwner()
+	e, err := q.Only(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	return NewSevOwnerRead(e), nil
+}
+
 // CreateUe handles POST /ues requests.
 func (h *OgentHandler) CreateUe(ctx context.Context, req *CreateUeReq) (CreateUeRes, error) {
 	b := h.client.Ue.Create()
@@ -1671,3 +1942,39 @@ func (h *OgentHandler) ListUserMa(ctx context.Context, params ListUserMaParams)
 	r := NewUserMaLists(es)
 	return (*ListUserMaOKApplicationJSON)(&r), nil
 }
+
+// ListUserSev handles GET /users/{id}/sev requests.
+func (h *OgentHandler) ListUserSev(ctx context.Context, params ListUserSevParams) (ListUserSevRes, error) {
+	q := h.client.User.Query().Where(user.IDEQ(params.ID)).QuerySev()
+	page := 1
+	if v, ok := params.Page.Get(); ok {
+		page = v
+	}
+	itemsPerPage := 30
+	if v, ok := params.ItemsPerPage.Get(); ok {
+		itemsPerPage = v
+	}
+	q.Limit(itemsPerPage).Offset((page - 1) * itemsPerPage)
+	es, err := q.All(ctx)
+	if err != nil {
+		switch {
+		case ent.IsNotFound(err):
+			return &R404{
+				Code:   http.StatusNotFound,
+				Status: http.StatusText(http.StatusNotFound),
+				Errors: rawError(err),
+			}, nil
+		case ent.IsNotSingular(err):
+			return &R409{
+				Code:   http.StatusConflict,
+				Status: http.StatusText(http.StatusConflict),
+				Errors: rawError(err),
+			}, nil
+		default:
+			// Let the server handle the error.
+			return nil, err
+		}
+	}
+	r := NewUserSevLists(es)
+	return (*ListUserSevOKApplicationJSON)(&r), nil
+}