demo_types.pb.gorm.go

package example

import (
	context "context"
	fmt "fmt"
	auth "github.com/infobloxopen/atlas-app-toolkit/auth"
	gateway "github.com/infobloxopen/atlas-app-toolkit/gateway"
	gorm1 "github.com/infobloxopen/atlas-app-toolkit/gorm"
	errors "github.com/MichaelSkuratovichNS/protoc-gen-gorm/errors"
	user "github.com/MichaelSkuratovichNS/protoc-gen-gorm/example/user"
	types "github.com/MichaelSkuratovichNS/protoc-gen-gorm/types"
	pq "github.com/lib/pq"
	go_uuid "github.com/satori/go.uuid"
	field_mask "google.golang.org/genproto/protobuf/field_mask"
	emptypb "google.golang.org/protobuf/types/known/emptypb"
	timestamppb "google.golang.org/protobuf/types/known/timestamppb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
	gorm "gorm.io/gorm"
	big "math/big"
	strings "strings"
	time "time"
)

type TestTypesORM struct {
	ANestedObjectTypeWithIDId *uint32
	Array                     pq.StringArray
	Array2                    pq.StringArray
	BecomesInt                string
	Bigint                    *big.Int `gorm:"type:numeric"`
	CreatedAt                 *time.Time
	JsonField                 *types.Jsonb  `gorm:"type:jsonb"`
	NullableUuid              *go_uuid.UUID `gorm:"type:uuid"`
	OptionalString            *string
	ThingsTypeWithIDId        *uint32
	TimeOnly                  string `gorm:"type:time"`
	TypeWithIdId              uint32
	Uuid                      go_uuid.UUID `gorm:"type:uuid"`
}

// TableName overrides the default tablename generated by GORM
func (TestTypesORM) TableName() string {
	return "smorgasbord"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestTypes) ToORM(ctx context.Context) (TestTypesORM, error) {
	to := TestTypesORM{}
	var err error
	if prehook, ok := interface{}(m).(TestTypesWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	// Repeated type int32 is not an ORMable message type
	if m.OptionalString != nil {
		v := m.OptionalString.Value
		to.OptionalString = &v
	}
	to.BecomesInt = TestTypesStatus_name[int32(m.BecomesInt)]
	if m.Uuid != nil {
		to.Uuid, err = go_uuid.FromString(m.Uuid.Value)
		if err != nil {
			return to, err
		}
	} else {
		to.Uuid = go_uuid.Nil
	}
	if m.CreatedAt != nil {
		t := m.CreatedAt.AsTime()
		to.CreatedAt = &t
	}
	to.TypeWithIdId = m.TypeWithIdId
	if m.JsonField != nil {
		to.JsonField = &types.Jsonb{[]byte(m.JsonField.Value)}
	}
	if m.NullableUuid != nil {
		tempUUID, uErr := go_uuid.FromString(m.NullableUuid.Value)
		if uErr != nil {
			return to, uErr
		}
		to.NullableUuid = &tempUUID
	}
	if m.TimeOnly != nil {
		if to.TimeOnly, err = types.ParseTime(m.TimeOnly.Value); err != nil {
			return to, err
		}
	}
	if m.Bigint != nil {
		var ok bool
		to.Bigint = new(big.Int)
		to.Bigint, ok = to.Bigint.SetString(m.Bigint.Value, 0)
		if !ok {
			return to, fmt.Errorf("unable convert Bigint to big.Int")
		}
	}
	if posthook, ok := interface{}(m).(TestTypesWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestTypesORM) ToPB(ctx context.Context) (TestTypes, error) {
	to := TestTypes{}
	var err error
	if prehook, ok := interface{}(m).(TestTypesWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	// Repeated type int32 is not an ORMable message type
	if m.OptionalString != nil {
		to.OptionalString = &wrapperspb.StringValue{Value: *m.OptionalString}
	}
	to.BecomesInt = TestTypesStatus(TestTypesStatus_value[m.BecomesInt])
	to.Uuid = &types.UUID{Value: m.Uuid.String()}
	if m.CreatedAt != nil {
		to.CreatedAt = timestamppb.New(*m.CreatedAt)
	}
	to.TypeWithIdId = m.TypeWithIdId
	if m.JsonField != nil {
		to.JsonField = &types.JSONValue{Value: string(m.JsonField.RawMessage)}
	}
	if m.NullableUuid != nil {
		to.NullableUuid = &types.UUIDValue{Value: m.NullableUuid.String()}
	}
	if m.TimeOnly != "" {
		if to.TimeOnly, err = types.TimeOnlyByString(m.TimeOnly); err != nil {
			return to, err
		}
	}
	to.Bigint = &types.BigInt{Value: m.Bigint.String()}
	if posthook, ok := interface{}(m).(TestTypesWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestTypes the arg will be the target, the caller the one being converted from

// TestTypesBeforeToORM called before default ToORM code
type TestTypesWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestTypesORM) error
}

// TestTypesAfterToORM called after default ToORM code
type TestTypesWithAfterToORM interface {
	AfterToORM(context.Context, *TestTypesORM) error
}

// TestTypesBeforeToPB called before default ToPB code
type TestTypesWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestTypes) error
}

// TestTypesAfterToPB called after default ToPB code
type TestTypesWithAfterToPB interface {
	AfterToPB(context.Context, *TestTypes) error
}

type TypeWithIDORM struct {
	ANestedObject     *TestTypesORM `gorm:"foreignKey:ANestedObjectTypeWithIDId;references:Id"`
	Address           *types.Inet   `gorm:"type:inet"`
	DeletedAt         *time.Time
	DoubleField       *float64
	FloatField        *float32
	Id                uint32
	IntPointId        *uint32
	Ip                string          `gorm:"column:ip_addr"`
	MultiAccountTypes []*JoinTable    `gorm:"foreignKey:TypeWithIDID"`
	Point             *IntPointORM    `gorm:"foreignKey:IntPointId;references:Id"`
	SecretInt         int32           `gorm:"-"`
	TagSizeTest       string          `gorm:"size:512"`
	TagTest           float32         `gorm:"type:float;precision:6"`
	Things            []*TestTypesORM `gorm:"foreignKey:ThingsTypeWithIDId;references:Id"`
	TimeOnly          string          `gorm:"type:time"`
	User              *user.UserORM   `gorm:"foreignKey:UserId;references:Id"`
	UserId            *string
}

// TableName overrides the default tablename generated by GORM
func (TypeWithIDORM) TableName() string {
	return "type_with_ids"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TypeWithID) ToORM(ctx context.Context) (TypeWithIDORM, error) {
	to := TypeWithIDORM{}
	var err error
	if prehook, ok := interface{}(m).(TypeWithIDWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Ip = m.Ip
	for _, v := range m.Things {
		if v != nil {
			if tempThings, cErr := v.ToORM(ctx); cErr == nil {
				to.Things = append(to.Things, &tempThings)
			} else {
				return to, cErr
			}
		} else {
			to.Things = append(to.Things, nil)
		}
	}
	if m.ANestedObject != nil {
		tempANestedObject, err := m.ANestedObject.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.ANestedObject = &tempANestedObject
	}
	if m.Point != nil {
		tempPoint, err := m.Point.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.Point = &tempPoint
	}
	if m.User != nil {
		tempUser, err := m.User.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.User = &tempUser
	}
	if m.Address != nil {
		if to.Address, err = types.ParseInet(m.Address.Value); err != nil {
			return to, err
		}
	}
	to.TagTest = m.TagTest
	to.TagSizeTest = m.TagSizeTest
	if m.FloatField != nil {
		v := m.FloatField.Value
		to.FloatField = &v
	}
	if m.DoubleField != nil {
		v := m.DoubleField.Value
		to.DoubleField = &v
	}
	if m.TimeOnly != nil {
		if to.TimeOnly, err = types.ParseTime(m.TimeOnly.Value); err != nil {
			return to, err
		}
	}
	if m.DeletedAt != nil {
		t := m.DeletedAt.AsTime()
		to.DeletedAt = &t
	}
	if posthook, ok := interface{}(m).(TypeWithIDWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TypeWithIDORM) ToPB(ctx context.Context) (TypeWithID, error) {
	to := TypeWithID{}
	var err error
	if prehook, ok := interface{}(m).(TypeWithIDWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.Ip = m.Ip
	for _, v := range m.Things {
		if v != nil {
			if tempThings, cErr := v.ToPB(ctx); cErr == nil {
				to.Things = append(to.Things, &tempThings)
			} else {
				return to, cErr
			}
		} else {
			to.Things = append(to.Things, nil)
		}
	}
	if m.ANestedObject != nil {
		tempANestedObject, err := m.ANestedObject.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.ANestedObject = &tempANestedObject
	}
	if m.Point != nil {
		tempPoint, err := m.Point.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.Point = &tempPoint
	}
	if m.User != nil {
		tempUser, err := m.User.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.User = &tempUser
	}
	if m.Address != nil && m.Address.IPNet != nil {
		to.Address = &types.InetValue{Value: m.Address.String()}
	}
	to.TagTest = m.TagTest
	to.TagSizeTest = m.TagSizeTest
	if m.FloatField != nil {
		to.FloatField = &wrapperspb.FloatValue{Value: *m.FloatField}
	}
	if m.DoubleField != nil {
		to.DoubleField = &wrapperspb.DoubleValue{Value: *m.DoubleField}
	}
	if m.TimeOnly != "" {
		if to.TimeOnly, err = types.TimeOnlyByString(m.TimeOnly); err != nil {
			return to, err
		}
	}
	if m.DeletedAt != nil {
		to.DeletedAt = timestamppb.New(*m.DeletedAt)
	}
	if posthook, ok := interface{}(m).(TypeWithIDWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TypeWithID the arg will be the target, the caller the one being converted from

// TypeWithIDBeforeToORM called before default ToORM code
type TypeWithIDWithBeforeToORM interface {
	BeforeToORM(context.Context, *TypeWithIDORM) error
}

// TypeWithIDAfterToORM called after default ToORM code
type TypeWithIDWithAfterToORM interface {
	AfterToORM(context.Context, *TypeWithIDORM) error
}

// TypeWithIDBeforeToPB called before default ToPB code
type TypeWithIDWithBeforeToPB interface {
	BeforeToPB(context.Context, *TypeWithID) error
}

// TypeWithIDAfterToPB called after default ToPB code
type TypeWithIDWithAfterToPB interface {
	AfterToPB(context.Context, *TypeWithID) error
}

type MultiaccountTypeWithIDORM struct {
	AccountID string
	Id        uint64
	SomeField string
}

// TableName overrides the default tablename generated by GORM
func (MultiaccountTypeWithIDORM) TableName() string {
	return "multiaccount_type_with_ids"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *MultiaccountTypeWithID) ToORM(ctx context.Context) (MultiaccountTypeWithIDORM, error) {
	to := MultiaccountTypeWithIDORM{}
	var err error
	if prehook, ok := interface{}(m).(MultiaccountTypeWithIDWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.SomeField = m.SomeField
	accountID, err := auth.GetAccountID(ctx, nil)
	if err != nil {
		return to, err
	}
	to.AccountID = accountID
	if posthook, ok := interface{}(m).(MultiaccountTypeWithIDWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *MultiaccountTypeWithIDORM) ToPB(ctx context.Context) (MultiaccountTypeWithID, error) {
	to := MultiaccountTypeWithID{}
	var err error
	if prehook, ok := interface{}(m).(MultiaccountTypeWithIDWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	to.SomeField = m.SomeField
	if posthook, ok := interface{}(m).(MultiaccountTypeWithIDWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type MultiaccountTypeWithID the arg will be the target, the caller the one being converted from

// MultiaccountTypeWithIDBeforeToORM called before default ToORM code
type MultiaccountTypeWithIDWithBeforeToORM interface {
	BeforeToORM(context.Context, *MultiaccountTypeWithIDORM) error
}

// MultiaccountTypeWithIDAfterToORM called after default ToORM code
type MultiaccountTypeWithIDWithAfterToORM interface {
	AfterToORM(context.Context, *MultiaccountTypeWithIDORM) error
}

// MultiaccountTypeWithIDBeforeToPB called before default ToPB code
type MultiaccountTypeWithIDWithBeforeToPB interface {
	BeforeToPB(context.Context, *MultiaccountTypeWithID) error
}

// MultiaccountTypeWithIDAfterToPB called after default ToPB code
type MultiaccountTypeWithIDWithAfterToPB interface {
	AfterToPB(context.Context, *MultiaccountTypeWithID) error
}

type MultiaccountTypeWithoutIDORM struct {
	AccountID string
	SomeField string
}

// TableName overrides the default tablename generated by GORM
func (MultiaccountTypeWithoutIDORM) TableName() string {
	return "multiaccount_type_without_ids"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *MultiaccountTypeWithoutID) ToORM(ctx context.Context) (MultiaccountTypeWithoutIDORM, error) {
	to := MultiaccountTypeWithoutIDORM{}
	var err error
	if prehook, ok := interface{}(m).(MultiaccountTypeWithoutIDWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.SomeField = m.SomeField
	accountID, err := auth.GetAccountID(ctx, nil)
	if err != nil {
		return to, err
	}
	to.AccountID = accountID
	if posthook, ok := interface{}(m).(MultiaccountTypeWithoutIDWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *MultiaccountTypeWithoutIDORM) ToPB(ctx context.Context) (MultiaccountTypeWithoutID, error) {
	to := MultiaccountTypeWithoutID{}
	var err error
	if prehook, ok := interface{}(m).(MultiaccountTypeWithoutIDWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.SomeField = m.SomeField
	if posthook, ok := interface{}(m).(MultiaccountTypeWithoutIDWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type MultiaccountTypeWithoutID the arg will be the target, the caller the one being converted from

// MultiaccountTypeWithoutIDBeforeToORM called before default ToORM code
type MultiaccountTypeWithoutIDWithBeforeToORM interface {
	BeforeToORM(context.Context, *MultiaccountTypeWithoutIDORM) error
}

// MultiaccountTypeWithoutIDAfterToORM called after default ToORM code
type MultiaccountTypeWithoutIDWithAfterToORM interface {
	AfterToORM(context.Context, *MultiaccountTypeWithoutIDORM) error
}

// MultiaccountTypeWithoutIDBeforeToPB called before default ToPB code
type MultiaccountTypeWithoutIDWithBeforeToPB interface {
	BeforeToPB(context.Context, *MultiaccountTypeWithoutID) error
}

// MultiaccountTypeWithoutIDAfterToPB called after default ToPB code
type MultiaccountTypeWithoutIDWithAfterToPB interface {
	AfterToPB(context.Context, *MultiaccountTypeWithoutID) error
}

type PrimaryUUIDTypeORM struct {
	Child *ExternalChildORM `gorm:"foreignKey:PrimaryUUIDTypeId;references:Id"`
	Id    *go_uuid.UUID     `gorm:"type:uuid"`
}

// TableName overrides the default tablename generated by GORM
func (PrimaryUUIDTypeORM) TableName() string {
	return "primary_uuid_types"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *PrimaryUUIDType) ToORM(ctx context.Context) (PrimaryUUIDTypeORM, error) {
	to := PrimaryUUIDTypeORM{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryUUIDTypeWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	if m.Id != nil {
		tempUUID, uErr := go_uuid.FromString(m.Id.Value)
		if uErr != nil {
			return to, uErr
		}
		to.Id = &tempUUID
	}
	if m.Child != nil {
		tempChild, err := m.Child.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryUUIDTypeWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *PrimaryUUIDTypeORM) ToPB(ctx context.Context) (PrimaryUUIDType, error) {
	to := PrimaryUUIDType{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryUUIDTypeWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	if m.Id != nil {
		to.Id = &types.UUIDValue{Value: m.Id.String()}
	}
	if m.Child != nil {
		tempChild, err := m.Child.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryUUIDTypeWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type PrimaryUUIDType the arg will be the target, the caller the one being converted from

// PrimaryUUIDTypeBeforeToORM called before default ToORM code
type PrimaryUUIDTypeWithBeforeToORM interface {
	BeforeToORM(context.Context, *PrimaryUUIDTypeORM) error
}

// PrimaryUUIDTypeAfterToORM called after default ToORM code
type PrimaryUUIDTypeWithAfterToORM interface {
	AfterToORM(context.Context, *PrimaryUUIDTypeORM) error
}

// PrimaryUUIDTypeBeforeToPB called before default ToPB code
type PrimaryUUIDTypeWithBeforeToPB interface {
	BeforeToPB(context.Context, *PrimaryUUIDType) error
}

// PrimaryUUIDTypeAfterToPB called after default ToPB code
type PrimaryUUIDTypeWithAfterToPB interface {
	AfterToPB(context.Context, *PrimaryUUIDType) error
}

type PrimaryStringTypeORM struct {
	Child *ExternalChildORM `gorm:"foreignKey:PrimaryStringTypeId;references:Id"`
	Id    string
}

// TableName overrides the default tablename generated by GORM
func (PrimaryStringTypeORM) TableName() string {
	return "primary_string_types"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *PrimaryStringType) ToORM(ctx context.Context) (PrimaryStringTypeORM, error) {
	to := PrimaryStringTypeORM{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryStringTypeWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	if m.Child != nil {
		tempChild, err := m.Child.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryStringTypeWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *PrimaryStringTypeORM) ToPB(ctx context.Context) (PrimaryStringType, error) {
	to := PrimaryStringType{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryStringTypeWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	if m.Child != nil {
		tempChild, err := m.Child.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryStringTypeWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type PrimaryStringType the arg will be the target, the caller the one being converted from

// PrimaryStringTypeBeforeToORM called before default ToORM code
type PrimaryStringTypeWithBeforeToORM interface {
	BeforeToORM(context.Context, *PrimaryStringTypeORM) error
}

// PrimaryStringTypeAfterToORM called after default ToORM code
type PrimaryStringTypeWithAfterToORM interface {
	AfterToORM(context.Context, *PrimaryStringTypeORM) error
}

// PrimaryStringTypeBeforeToPB called before default ToPB code
type PrimaryStringTypeWithBeforeToPB interface {
	BeforeToPB(context.Context, *PrimaryStringType) error
}

// PrimaryStringTypeAfterToPB called after default ToPB code
type PrimaryStringTypeWithAfterToPB interface {
	AfterToPB(context.Context, *PrimaryStringType) error
}

type TestTagORM struct {
	Id           string
	TestTagAssoc *TestTagAssociationORM `gorm:"foreignKey:TestTagId;references:Id"`
}

// TableName overrides the default tablename generated by GORM
func (TestTagORM) TableName() string {
	return "test_tags"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestTag) ToORM(ctx context.Context) (TestTagORM, error) {
	to := TestTagORM{}
	var err error
	if prehook, ok := interface{}(m).(TestTagWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	if m.TestTagAssoc != nil {
		tempTestTagAssoc, err := m.TestTagAssoc.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.TestTagAssoc = &tempTestTagAssoc
	}
	if posthook, ok := interface{}(m).(TestTagWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestTagORM) ToPB(ctx context.Context) (TestTag, error) {
	to := TestTag{}
	var err error
	if prehook, ok := interface{}(m).(TestTagWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	if m.TestTagAssoc != nil {
		tempTestTagAssoc, err := m.TestTagAssoc.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.TestTagAssoc = &tempTestTagAssoc
	}
	if posthook, ok := interface{}(m).(TestTagWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestTag the arg will be the target, the caller the one being converted from

// TestTagBeforeToORM called before default ToORM code
type TestTagWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestTagORM) error
}

// TestTagAfterToORM called after default ToORM code
type TestTagWithAfterToORM interface {
	AfterToORM(context.Context, *TestTagORM) error
}

// TestTagBeforeToPB called before default ToPB code
type TestTagWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestTag) error
}

// TestTagAfterToPB called after default ToPB code
type TestTagWithAfterToPB interface {
	AfterToPB(context.Context, *TestTag) error
}

type TestAssocHandlerDefaultORM struct {
	Id           string
	TestTagAssoc []*TestTagAssociationORM `gorm:"foreignKey:TestAssocHandlerDefaultId;references:Id"`
}

// TableName overrides the default tablename generated by GORM
func (TestAssocHandlerDefaultORM) TableName() string {
	return "test_assoc_handler_defaults"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestAssocHandlerDefault) ToORM(ctx context.Context) (TestAssocHandlerDefaultORM, error) {
	to := TestAssocHandlerDefaultORM{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerDefaultWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToORM(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerDefaultWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestAssocHandlerDefaultORM) ToPB(ctx context.Context) (TestAssocHandlerDefault, error) {
	to := TestAssocHandlerDefault{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerDefaultWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToPB(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerDefaultWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestAssocHandlerDefault the arg will be the target, the caller the one being converted from

// TestAssocHandlerDefaultBeforeToORM called before default ToORM code
type TestAssocHandlerDefaultWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestAssocHandlerDefaultORM) error
}

// TestAssocHandlerDefaultAfterToORM called after default ToORM code
type TestAssocHandlerDefaultWithAfterToORM interface {
	AfterToORM(context.Context, *TestAssocHandlerDefaultORM) error
}

// TestAssocHandlerDefaultBeforeToPB called before default ToPB code
type TestAssocHandlerDefaultWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestAssocHandlerDefault) error
}

// TestAssocHandlerDefaultAfterToPB called after default ToPB code
type TestAssocHandlerDefaultWithAfterToPB interface {
	AfterToPB(context.Context, *TestAssocHandlerDefault) error
}

type TestAssocHandlerReplaceORM struct {
	Id           string
	TestTagAssoc []*TestTagAssociationORM `gorm:"foreignKey:TestAssocHandlerReplaceId;references:Id;replace:true"`
}

// TableName overrides the default tablename generated by GORM
func (TestAssocHandlerReplaceORM) TableName() string {
	return "test_assoc_handler_replaces"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestAssocHandlerReplace) ToORM(ctx context.Context) (TestAssocHandlerReplaceORM, error) {
	to := TestAssocHandlerReplaceORM{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerReplaceWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToORM(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerReplaceWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestAssocHandlerReplaceORM) ToPB(ctx context.Context) (TestAssocHandlerReplace, error) {
	to := TestAssocHandlerReplace{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerReplaceWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToPB(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerReplaceWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestAssocHandlerReplace the arg will be the target, the caller the one being converted from

// TestAssocHandlerReplaceBeforeToORM called before default ToORM code
type TestAssocHandlerReplaceWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestAssocHandlerReplaceORM) error
}

// TestAssocHandlerReplaceAfterToORM called after default ToORM code
type TestAssocHandlerReplaceWithAfterToORM interface {
	AfterToORM(context.Context, *TestAssocHandlerReplaceORM) error
}

// TestAssocHandlerReplaceBeforeToPB called before default ToPB code
type TestAssocHandlerReplaceWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestAssocHandlerReplace) error
}

// TestAssocHandlerReplaceAfterToPB called after default ToPB code
type TestAssocHandlerReplaceWithAfterToPB interface {
	AfterToPB(context.Context, *TestAssocHandlerReplace) error
}

type TestAssocHandlerClearORM struct {
	Id           string
	TestTagAssoc []*TestTagAssociationORM `gorm:"foreignKey:TestAssocHandlerClearId;references:Id;clear:true"`
}

// TableName overrides the default tablename generated by GORM
func (TestAssocHandlerClearORM) TableName() string {
	return "test_assoc_handler_clears"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestAssocHandlerClear) ToORM(ctx context.Context) (TestAssocHandlerClearORM, error) {
	to := TestAssocHandlerClearORM{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerClearWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToORM(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerClearWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestAssocHandlerClearORM) ToPB(ctx context.Context) (TestAssocHandlerClear, error) {
	to := TestAssocHandlerClear{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerClearWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToPB(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerClearWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestAssocHandlerClear the arg will be the target, the caller the one being converted from

// TestAssocHandlerClearBeforeToORM called before default ToORM code
type TestAssocHandlerClearWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestAssocHandlerClearORM) error
}

// TestAssocHandlerClearAfterToORM called after default ToORM code
type TestAssocHandlerClearWithAfterToORM interface {
	AfterToORM(context.Context, *TestAssocHandlerClearORM) error
}

// TestAssocHandlerClearBeforeToPB called before default ToPB code
type TestAssocHandlerClearWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestAssocHandlerClear) error
}

// TestAssocHandlerClearAfterToPB called after default ToPB code
type TestAssocHandlerClearWithAfterToPB interface {
	AfterToPB(context.Context, *TestAssocHandlerClear) error
}

type TestAssocHandlerAppendORM struct {
	Id           string
	TestTagAssoc []*TestTagAssociationORM `gorm:"foreignKey:TestAssocHandlerAppendId;references:Id;append:true"`
}

// TableName overrides the default tablename generated by GORM
func (TestAssocHandlerAppendORM) TableName() string {
	return "test_assoc_handler_appends"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestAssocHandlerAppend) ToORM(ctx context.Context) (TestAssocHandlerAppendORM, error) {
	to := TestAssocHandlerAppendORM{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerAppendWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToORM(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerAppendWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestAssocHandlerAppendORM) ToPB(ctx context.Context) (TestAssocHandlerAppend, error) {
	to := TestAssocHandlerAppend{}
	var err error
	if prehook, ok := interface{}(m).(TestAssocHandlerAppendWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.Id = m.Id
	for _, v := range m.TestTagAssoc {
		if v != nil {
			if tempTestTagAssoc, cErr := v.ToPB(ctx); cErr == nil {
				to.TestTagAssoc = append(to.TestTagAssoc, &tempTestTagAssoc)
			} else {
				return to, cErr
			}
		} else {
			to.TestTagAssoc = append(to.TestTagAssoc, nil)
		}
	}
	if posthook, ok := interface{}(m).(TestAssocHandlerAppendWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestAssocHandlerAppend the arg will be the target, the caller the one being converted from

// TestAssocHandlerAppendBeforeToORM called before default ToORM code
type TestAssocHandlerAppendWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestAssocHandlerAppendORM) error
}

// TestAssocHandlerAppendAfterToORM called after default ToORM code
type TestAssocHandlerAppendWithAfterToORM interface {
	AfterToORM(context.Context, *TestAssocHandlerAppendORM) error
}

// TestAssocHandlerAppendBeforeToPB called before default ToPB code
type TestAssocHandlerAppendWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestAssocHandlerAppend) error
}

// TestAssocHandlerAppendAfterToPB called after default ToPB code
type TestAssocHandlerAppendWithAfterToPB interface {
	AfterToPB(context.Context, *TestAssocHandlerAppend) error
}

type TestTagAssociationORM struct {
	SomeField                 string
	TestAssocHandlerAppendId  *string
	TestAssocHandlerClearId   *string
	TestAssocHandlerDefaultId *string
	TestAssocHandlerReplaceId *string
	TestTagId                 *string
}

// TableName overrides the default tablename generated by GORM
func (TestTagAssociationORM) TableName() string {
	return "test_tag_associations"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *TestTagAssociation) ToORM(ctx context.Context) (TestTagAssociationORM, error) {
	to := TestTagAssociationORM{}
	var err error
	if prehook, ok := interface{}(m).(TestTagAssociationWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	to.SomeField = m.SomeField
	if posthook, ok := interface{}(m).(TestTagAssociationWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *TestTagAssociationORM) ToPB(ctx context.Context) (TestTagAssociation, error) {
	to := TestTagAssociation{}
	var err error
	if prehook, ok := interface{}(m).(TestTagAssociationWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	to.SomeField = m.SomeField
	if posthook, ok := interface{}(m).(TestTagAssociationWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type TestTagAssociation the arg will be the target, the caller the one being converted from

// TestTagAssociationBeforeToORM called before default ToORM code
type TestTagAssociationWithBeforeToORM interface {
	BeforeToORM(context.Context, *TestTagAssociationORM) error
}

// TestTagAssociationAfterToORM called after default ToORM code
type TestTagAssociationWithAfterToORM interface {
	AfterToORM(context.Context, *TestTagAssociationORM) error
}

// TestTagAssociationBeforeToPB called before default ToPB code
type TestTagAssociationWithBeforeToPB interface {
	BeforeToPB(context.Context, *TestTagAssociation) error
}

// TestTagAssociationAfterToPB called after default ToPB code
type TestTagAssociationWithAfterToPB interface {
	AfterToPB(context.Context, *TestTagAssociation) error
}

type PrimaryIncludedORM struct {
	Child *ExternalChildORM `gorm:"foreignKey:PrimaryIncludedId;references:Id"`
	Id    go_uuid.UUID
}

// TableName overrides the default tablename generated by GORM
func (PrimaryIncludedORM) TableName() string {
	return "primary_includeds"
}

// ToORM runs the BeforeToORM hook if present, converts the fields of this
// object to ORM format, runs the AfterToORM hook, then returns the ORM object
func (m *PrimaryIncluded) ToORM(ctx context.Context) (PrimaryIncludedORM, error) {
	to := PrimaryIncludedORM{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryIncludedWithBeforeToORM); ok {
		if err = prehook.BeforeToORM(ctx, &to); err != nil {
			return to, err
		}
	}
	if m.Child != nil {
		tempChild, err := m.Child.ToORM(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryIncludedWithAfterToORM); ok {
		err = posthook.AfterToORM(ctx, &to)
	}
	return to, err
}

// ToPB runs the BeforeToPB hook if present, converts the fields of this
// object to PB format, runs the AfterToPB hook, then returns the PB object
func (m *PrimaryIncludedORM) ToPB(ctx context.Context) (PrimaryIncluded, error) {
	to := PrimaryIncluded{}
	var err error
	if prehook, ok := interface{}(m).(PrimaryIncludedWithBeforeToPB); ok {
		if err = prehook.BeforeToPB(ctx, &to); err != nil {
			return to, err
		}
	}
	if m.Child != nil {
		tempChild, err := m.Child.ToPB(ctx)
		if err != nil {
			return to, err
		}
		to.Child = &tempChild
	}
	if posthook, ok := interface{}(m).(PrimaryIncludedWithAfterToPB); ok {
		err = posthook.AfterToPB(ctx, &to)
	}
	return to, err
}

// The following are interfaces you can implement for special behavior during ORM/PB conversions
// of type PrimaryIncluded the arg will be the target, the caller the one being converted from

// PrimaryIncludedBeforeToORM called before default ToORM code
type PrimaryIncludedWithBeforeToORM interface {
	BeforeToORM(context.Context, *PrimaryIncludedORM) error
}

// PrimaryIncludedAfterToORM called after default ToORM code
type PrimaryIncludedWithAfterToORM interface {
	AfterToORM(context.Context, *PrimaryIncludedORM) error
}

// PrimaryIncludedBeforeToPB called before default ToPB code
type PrimaryIncludedWithBeforeToPB interface {
	BeforeToPB(context.Context, *PrimaryIncluded) error
}

// PrimaryIncludedAfterToPB called after default ToPB code
type PrimaryIncludedWithAfterToPB interface {
	AfterToPB(context.Context, *PrimaryIncluded) error
}

// DefaultCreateTestTypes executes a basic gorm create call
func DefaultCreateTestTypes(ctx context.Context, in *TestTypes, db *gorm.DB) (*TestTypes, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTypesORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTypesORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestTypesORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTypesORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

// DefaultApplyFieldMaskTestTypes patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTypes(ctx context.Context, patchee *TestTypes, patcher *TestTypes, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestTypes, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedOptionalString bool
	var updatedNothingness bool
	var updatedCreatedAt bool
	var updatedJsonField bool
	for i, f := range updateMask.Paths {
		if f == prefix+"ApiOnlyString" {
			patchee.ApiOnlyString = patcher.ApiOnlyString
			continue
		}
		if f == prefix+"Numbers" {
			patchee.Numbers = patcher.Numbers
			continue
		}
		if !updatedOptionalString && strings.HasPrefix(f, prefix+"OptionalString.") {
			if patcher.OptionalString == nil {
				patchee.OptionalString = nil
				continue
			}
			if patchee.OptionalString == nil {
				patchee.OptionalString = &wrapperspb.StringValue{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"OptionalString."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.OptionalString, patchee.OptionalString, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"OptionalString" {
			updatedOptionalString = true
			patchee.OptionalString = patcher.OptionalString
			continue
		}
		if f == prefix+"BecomesInt" {
			patchee.BecomesInt = patcher.BecomesInt
			continue
		}
		if !updatedNothingness && strings.HasPrefix(f, prefix+"Nothingness.") {
			if patcher.Nothingness == nil {
				patchee.Nothingness = nil
				continue
			}
			if patchee.Nothingness == nil {
				patchee.Nothingness = &emptypb.Empty{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"Nothingness."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.Nothingness, patchee.Nothingness, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"Nothingness" {
			updatedNothingness = true
			patchee.Nothingness = patcher.Nothingness
			continue
		}
		if f == prefix+"Uuid" {
			patchee.Uuid = patcher.Uuid
			continue
		}
		if !updatedCreatedAt && strings.HasPrefix(f, prefix+"CreatedAt.") {
			if patcher.CreatedAt == nil {
				patchee.CreatedAt = nil
				continue
			}
			if patchee.CreatedAt == nil {
				patchee.CreatedAt = &timestamppb.Timestamp{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"CreatedAt."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.CreatedAt, patchee.CreatedAt, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"CreatedAt" {
			updatedCreatedAt = true
			patchee.CreatedAt = patcher.CreatedAt
			continue
		}
		if f == prefix+"TypeWithIdId" {
			patchee.TypeWithIdId = patcher.TypeWithIdId
			continue
		}
		if !updatedJsonField && strings.HasPrefix(f, prefix+"JsonField") {
			patchee.JsonField = patcher.JsonField
			updatedJsonField = true
			continue
		}
		if f == prefix+"NullableUuid" {
			patchee.NullableUuid = patcher.NullableUuid
			continue
		}
		if f == prefix+"TimeOnly" {
			patchee.TimeOnly = patcher.TimeOnly
			continue
		}
		if f == prefix+"Bigint" {
			patchee.Bigint = patcher.Bigint
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestTypes executes a gorm list call
func DefaultListTestTypes(ctx context.Context, db *gorm.DB) ([]*TestTypes, error) {
	in := TestTypes{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTypesORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestTypesORM{}, &TestTypes{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTypesORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	ormResponse := []TestTypesORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTypesORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestTypes{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestTypesORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTypesORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTypesORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestTypesORM) error
}

// DefaultCreateTypeWithID executes a basic gorm create call
func DefaultCreateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit("Emails", "Friends").Preload("Emails").Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TypeWithIDORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTypeWithID(ctx context.Context, in *TypeWithID, db *gorm.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TypeWithIDORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TypeWithIDORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TypeWithIDORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TypeWithIDORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTypeWithID(ctx context.Context, in *TypeWithID, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TypeWithIDORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TypeWithIDORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTypeWithIDSet(ctx context.Context, in []*TypeWithID, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []uint32{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == 0 {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TypeWithIDORM{})).(TypeWithIDORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TypeWithIDORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TypeWithIDORM{})).(TypeWithIDORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TypeWithIDORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TypeWithID, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TypeWithID, *gorm.DB) error
}

// DefaultStrictUpdateTypeWithID clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TypeWithIDORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterANestedObject := TestTypesORM{}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	filterANestedObject.ANestedObjectTypeWithIDId = new(uint32)
	*filterANestedObject.ANestedObjectTypeWithIDId = ormObj.Id
	if err = db.Where(filterANestedObject).Delete(TestTypesORM{}).Error; err != nil {
		return nil, err
	}
	filterThings := TestTypesORM{}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	filterThings.ThingsTypeWithIDId = new(uint32)
	*filterThings.ThingsTypeWithIDId = ormObj.Id
	if err = db.Where(filterThings).Delete(TestTypesORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit("Emails").Preload("Emails").Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TypeWithIDORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTypeWithID executes a basic gorm update call with patch behavior
func DefaultPatchTypeWithID(ctx context.Context, in *TypeWithID, updateMask *field_mask.FieldMask, db *gorm.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TypeWithID
	var err error
	if hook, ok := interface{}(&pbObj).(TypeWithIDWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTypeWithID(ctx, &TypeWithID{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TypeWithIDWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTypeWithID(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TypeWithIDWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTypeWithID(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TypeWithIDWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TypeWithIDWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TypeWithID, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTypeWithID executes a bulk gorm update call with patch behavior
func DefaultPatchSetTypeWithID(ctx context.Context, objects []*TypeWithID, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TypeWithID, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TypeWithID, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTypeWithID(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTypeWithID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTypeWithID(ctx context.Context, patchee *TypeWithID, patcher *TypeWithID, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TypeWithID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedANestedObject bool
	var updatedPoint bool
	var updatedUser bool
	var updatedSyntheticField bool
	var updatedFloatField bool
	var updatedDoubleField bool
	var updatedDeletedAt bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"Ip" {
			patchee.Ip = patcher.Ip
			continue
		}
		if f == prefix+"Things" {
			patchee.Things = patcher.Things
			continue
		}
		if !updatedANestedObject && strings.HasPrefix(f, prefix+"ANestedObject.") {
			updatedANestedObject = true
			if patcher.ANestedObject == nil {
				patchee.ANestedObject = nil
				continue
			}
			if patchee.ANestedObject == nil {
				patchee.ANestedObject = &TestTypes{}
			}
			if o, err := DefaultApplyFieldMaskTestTypes(ctx, patchee.ANestedObject, patcher.ANestedObject, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"ANestedObject.", db); err != nil {
				return nil, err
			} else {
				patchee.ANestedObject = o
			}
			continue
		}
		if f == prefix+"ANestedObject" {
			updatedANestedObject = true
			patchee.ANestedObject = patcher.ANestedObject
			continue
		}
		if !updatedPoint && strings.HasPrefix(f, prefix+"Point.") {
			updatedPoint = true
			if patcher.Point == nil {
				patchee.Point = nil
				continue
			}
			if patchee.Point == nil {
				patchee.Point = &IntPoint{}
			}
			if o, err := DefaultApplyFieldMaskIntPoint(ctx, patchee.Point, patcher.Point, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"Point.", db); err != nil {
				return nil, err
			} else {
				patchee.Point = o
			}
			continue
		}
		if f == prefix+"Point" {
			updatedPoint = true
			patchee.Point = patcher.Point
			continue
		}
		if !updatedUser && strings.HasPrefix(f, prefix+"User.") {
			updatedUser = true
			if patcher.User == nil {
				patchee.User = nil
				continue
			}
			if patchee.User == nil {
				patchee.User = &user.User{}
			}
			if o, err := user.DefaultApplyFieldMaskUser(ctx, patchee.User, patcher.User, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"User.", db); err != nil {
				return nil, err
			} else {
				patchee.User = o
			}
			continue
		}
		if f == prefix+"User" {
			updatedUser = true
			patchee.User = patcher.User
			continue
		}
		if f == prefix+"Address" {
			patchee.Address = patcher.Address
			continue
		}
		if f == prefix+"MultiaccountTypeIds" {
			patchee.MultiaccountTypeIds = patcher.MultiaccountTypeIds
			continue
		}
		if !updatedSyntheticField && strings.HasPrefix(f, prefix+"SyntheticField.") {
			if patcher.SyntheticField == nil {
				patchee.SyntheticField = nil
				continue
			}
			if patchee.SyntheticField == nil {
				patchee.SyntheticField = &APIOnlyType{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"SyntheticField."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.SyntheticField, patchee.SyntheticField, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"SyntheticField" {
			updatedSyntheticField = true
			patchee.SyntheticField = patcher.SyntheticField
			continue
		}
		if f == prefix+"TagTest" {
			patchee.TagTest = patcher.TagTest
			continue
		}
		if f == prefix+"TagSizeTest" {
			patchee.TagSizeTest = patcher.TagSizeTest
			continue
		}
		if !updatedFloatField && strings.HasPrefix(f, prefix+"FloatField.") {
			if patcher.FloatField == nil {
				patchee.FloatField = nil
				continue
			}
			if patchee.FloatField == nil {
				patchee.FloatField = &wrapperspb.FloatValue{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"FloatField."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.FloatField, patchee.FloatField, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"FloatField" {
			updatedFloatField = true
			patchee.FloatField = patcher.FloatField
			continue
		}
		if !updatedDoubleField && strings.HasPrefix(f, prefix+"DoubleField.") {
			if patcher.DoubleField == nil {
				patchee.DoubleField = nil
				continue
			}
			if patchee.DoubleField == nil {
				patchee.DoubleField = &wrapperspb.DoubleValue{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"DoubleField."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.DoubleField, patchee.DoubleField, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"DoubleField" {
			updatedDoubleField = true
			patchee.DoubleField = patcher.DoubleField
			continue
		}
		if f == prefix+"TimeOnly" {
			patchee.TimeOnly = patcher.TimeOnly
			continue
		}
		if !updatedDeletedAt && strings.HasPrefix(f, prefix+"DeletedAt.") {
			if patcher.DeletedAt == nil {
				patchee.DeletedAt = nil
				continue
			}
			if patchee.DeletedAt == nil {
				patchee.DeletedAt = &timestamppb.Timestamp{}
			}
			childMask := &field_mask.FieldMask{}
			for j := i; j < len(updateMask.Paths); j++ {
				if trimPath := strings.TrimPrefix(updateMask.Paths[j], prefix+"DeletedAt."); trimPath != updateMask.Paths[j] {
					childMask.Paths = append(childMask.Paths, trimPath)
				}
			}
			if err := gorm1.MergeWithMask(patcher.DeletedAt, patchee.DeletedAt, childMask); err != nil {
				return nil, nil
			}
		}
		if f == prefix+"DeletedAt" {
			updatedDeletedAt = true
			patchee.DeletedAt = patcher.DeletedAt
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTypeWithID executes a gorm list call
func DefaultListTypeWithID(ctx context.Context, db *gorm.DB) ([]*TypeWithID, error) {
	in := TypeWithID{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TypeWithIDORM{}, &TypeWithID{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TypeWithIDORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TypeWithID{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TypeWithIDORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TypeWithIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TypeWithIDORM) error
}

// DefaultCreateMultiaccountTypeWithID executes a basic gorm create call
func DefaultCreateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type MultiaccountTypeWithIDORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &MultiaccountTypeWithIDORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := MultiaccountTypeWithIDORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(MultiaccountTypeWithIDORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type MultiaccountTypeWithIDORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&MultiaccountTypeWithIDORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type MultiaccountTypeWithIDORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteMultiaccountTypeWithIDSet(ctx context.Context, in []*MultiaccountTypeWithID, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []uint64{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == 0 {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&MultiaccountTypeWithIDORM{})).(MultiaccountTypeWithIDORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	acctId, err := auth.GetAccountID(ctx, nil)
	if err != nil {
		return err
	}
	err = db.Where("account_id = ? AND id in (?)", acctId, keys).Delete(&MultiaccountTypeWithIDORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&MultiaccountTypeWithIDORM{})).(MultiaccountTypeWithIDORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type MultiaccountTypeWithIDORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*MultiaccountTypeWithID, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*MultiaccountTypeWithID, *gorm.DB) error
}

// DefaultStrictUpdateMultiaccountTypeWithID clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateMultiaccountTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	accountID, err := auth.GetAccountID(ctx, nil)
	if err != nil {
		return nil, err
	}
	db = db.Where(map[string]interface{}{"account_id": accountID})
	var count int64
	lockedRow := &MultiaccountTypeWithIDORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type MultiaccountTypeWithIDORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchMultiaccountTypeWithID executes a basic gorm update call with patch behavior
func DefaultPatchMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, updateMask *field_mask.FieldMask, db *gorm.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj MultiaccountTypeWithID
	var err error
	if hook, ok := interface{}(&pbObj).(MultiaccountTypeWithIDWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadMultiaccountTypeWithID(ctx, &MultiaccountTypeWithID{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(MultiaccountTypeWithIDWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskMultiaccountTypeWithID(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(MultiaccountTypeWithIDWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateMultiaccountTypeWithID(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(MultiaccountTypeWithIDWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type MultiaccountTypeWithIDWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *MultiaccountTypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *MultiaccountTypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *MultiaccountTypeWithID, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *MultiaccountTypeWithID, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetMultiaccountTypeWithID executes a bulk gorm update call with patch behavior
func DefaultPatchSetMultiaccountTypeWithID(ctx context.Context, objects []*MultiaccountTypeWithID, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*MultiaccountTypeWithID, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*MultiaccountTypeWithID, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchMultiaccountTypeWithID(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskMultiaccountTypeWithID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskMultiaccountTypeWithID(ctx context.Context, patchee *MultiaccountTypeWithID, patcher *MultiaccountTypeWithID, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*MultiaccountTypeWithID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"SomeField" {
			patchee.SomeField = patcher.SomeField
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListMultiaccountTypeWithID executes a gorm list call
func DefaultListMultiaccountTypeWithID(ctx context.Context, db *gorm.DB) ([]*MultiaccountTypeWithID, error) {
	in := MultiaccountTypeWithID{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &MultiaccountTypeWithIDORM{}, &MultiaccountTypeWithID{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []MultiaccountTypeWithIDORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*MultiaccountTypeWithID{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type MultiaccountTypeWithIDORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]MultiaccountTypeWithIDORM) error
}

// DefaultCreateMultiaccountTypeWithoutID executes a basic gorm create call
func DefaultCreateMultiaccountTypeWithoutID(ctx context.Context, in *MultiaccountTypeWithoutID, db *gorm.DB) (*MultiaccountTypeWithoutID, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type MultiaccountTypeWithoutIDORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithoutIDORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

// DefaultApplyFieldMaskMultiaccountTypeWithoutID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskMultiaccountTypeWithoutID(ctx context.Context, patchee *MultiaccountTypeWithoutID, patcher *MultiaccountTypeWithoutID, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*MultiaccountTypeWithoutID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"SomeField" {
			patchee.SomeField = patcher.SomeField
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListMultiaccountTypeWithoutID executes a gorm list call
func DefaultListMultiaccountTypeWithoutID(ctx context.Context, db *gorm.DB) ([]*MultiaccountTypeWithoutID, error) {
	in := MultiaccountTypeWithoutID{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &MultiaccountTypeWithoutIDORM{}, &MultiaccountTypeWithoutID{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	ormResponse := []MultiaccountTypeWithoutIDORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithoutIDORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*MultiaccountTypeWithoutID{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type MultiaccountTypeWithoutIDORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithoutIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type MultiaccountTypeWithoutIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]MultiaccountTypeWithoutIDORM) error
}

// DefaultCreatePrimaryUUIDType executes a basic gorm create call
func DefaultCreatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryUUIDTypeORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadPrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == nil || *ormObj.Id == go_uuid.Nil {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &PrimaryUUIDTypeORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := PrimaryUUIDTypeORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(PrimaryUUIDTypeORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryUUIDTypeORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == nil || *ormObj.Id == go_uuid.Nil {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&PrimaryUUIDTypeORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type PrimaryUUIDTypeORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryUUIDTypeSet(ctx context.Context, in []*PrimaryUUIDType, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []*go_uuid.UUID{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == nil || *ormObj.Id == go_uuid.Nil {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&PrimaryUUIDTypeORM{})).(PrimaryUUIDTypeORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&PrimaryUUIDTypeORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&PrimaryUUIDTypeORM{})).(PrimaryUUIDTypeORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type PrimaryUUIDTypeORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*PrimaryUUIDType, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*PrimaryUUIDType, *gorm.DB) error
}

// DefaultStrictUpdatePrimaryUUIDType clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdatePrimaryUUIDType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &PrimaryUUIDTypeORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterChild := ExternalChildORM{}
	if ormObj.Id == nil || *ormObj.Id == go_uuid.Nil {
		return nil, errors.EmptyIdError
	}
	filterChild.PrimaryUUIDTypeId = new(go_uuid.UUID)
	*filterChild.PrimaryUUIDTypeId = *ormObj.Id
	if err = db.Where(filterChild).Delete(ExternalChildORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type PrimaryUUIDTypeORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchPrimaryUUIDType executes a basic gorm update call with patch behavior
func DefaultPatchPrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, updateMask *field_mask.FieldMask, db *gorm.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj PrimaryUUIDType
	var err error
	if hook, ok := interface{}(&pbObj).(PrimaryUUIDTypeWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadPrimaryUUIDType(ctx, &PrimaryUUIDType{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(PrimaryUUIDTypeWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskPrimaryUUIDType(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(PrimaryUUIDTypeWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdatePrimaryUUIDType(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(PrimaryUUIDTypeWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type PrimaryUUIDTypeWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *PrimaryUUIDType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *PrimaryUUIDType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *PrimaryUUIDType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *PrimaryUUIDType, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetPrimaryUUIDType executes a bulk gorm update call with patch behavior
func DefaultPatchSetPrimaryUUIDType(ctx context.Context, objects []*PrimaryUUIDType, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*PrimaryUUIDType, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*PrimaryUUIDType, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchPrimaryUUIDType(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskPrimaryUUIDType patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryUUIDType(ctx context.Context, patchee *PrimaryUUIDType, patcher *PrimaryUUIDType, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*PrimaryUUIDType, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if !updatedChild && strings.HasPrefix(f, prefix+"Child.") {
			updatedChild = true
			if patcher.Child == nil {
				patchee.Child = nil
				continue
			}
			if patchee.Child == nil {
				patchee.Child = &ExternalChild{}
			}
			if o, err := DefaultApplyFieldMaskExternalChild(ctx, patchee.Child, patcher.Child, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"Child.", db); err != nil {
				return nil, err
			} else {
				patchee.Child = o
			}
			continue
		}
		if f == prefix+"Child" {
			updatedChild = true
			patchee.Child = patcher.Child
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListPrimaryUUIDType executes a gorm list call
func DefaultListPrimaryUUIDType(ctx context.Context, db *gorm.DB) ([]*PrimaryUUIDType, error) {
	in := PrimaryUUIDType{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &PrimaryUUIDTypeORM{}, &PrimaryUUIDType{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []PrimaryUUIDTypeORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*PrimaryUUIDType{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type PrimaryUUIDTypeORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryUUIDTypeORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]PrimaryUUIDTypeORM) error
}

// DefaultCreatePrimaryStringType executes a basic gorm create call
func DefaultCreatePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryStringTypeORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadPrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &PrimaryStringTypeORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := PrimaryStringTypeORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(PrimaryStringTypeORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryStringTypeORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&PrimaryStringTypeORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type PrimaryStringTypeORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryStringTypeSet(ctx context.Context, in []*PrimaryStringType, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&PrimaryStringTypeORM{})).(PrimaryStringTypeORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&PrimaryStringTypeORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&PrimaryStringTypeORM{})).(PrimaryStringTypeORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type PrimaryStringTypeORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*PrimaryStringType, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*PrimaryStringType, *gorm.DB) error
}

// DefaultStrictUpdatePrimaryStringType clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdatePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdatePrimaryStringType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &PrimaryStringTypeORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterChild := ExternalChildORM{}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	filterChild.PrimaryStringTypeId = new(string)
	*filterChild.PrimaryStringTypeId = ormObj.Id
	if err = db.Where(filterChild).Delete(ExternalChildORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type PrimaryStringTypeORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchPrimaryStringType executes a basic gorm update call with patch behavior
func DefaultPatchPrimaryStringType(ctx context.Context, in *PrimaryStringType, updateMask *field_mask.FieldMask, db *gorm.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj PrimaryStringType
	var err error
	if hook, ok := interface{}(&pbObj).(PrimaryStringTypeWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadPrimaryStringType(ctx, &PrimaryStringType{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(PrimaryStringTypeWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskPrimaryStringType(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(PrimaryStringTypeWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdatePrimaryStringType(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(PrimaryStringTypeWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type PrimaryStringTypeWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *PrimaryStringType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *PrimaryStringType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *PrimaryStringType, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *PrimaryStringType, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetPrimaryStringType executes a bulk gorm update call with patch behavior
func DefaultPatchSetPrimaryStringType(ctx context.Context, objects []*PrimaryStringType, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*PrimaryStringType, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*PrimaryStringType, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchPrimaryStringType(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskPrimaryStringType patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryStringType(ctx context.Context, patchee *PrimaryStringType, patcher *PrimaryStringType, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*PrimaryStringType, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if !updatedChild && strings.HasPrefix(f, prefix+"Child.") {
			updatedChild = true
			if patcher.Child == nil {
				patchee.Child = nil
				continue
			}
			if patchee.Child == nil {
				patchee.Child = &ExternalChild{}
			}
			if o, err := DefaultApplyFieldMaskExternalChild(ctx, patchee.Child, patcher.Child, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"Child.", db); err != nil {
				return nil, err
			} else {
				patchee.Child = o
			}
			continue
		}
		if f == prefix+"Child" {
			updatedChild = true
			patchee.Child = patcher.Child
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListPrimaryStringType executes a gorm list call
func DefaultListPrimaryStringType(ctx context.Context, db *gorm.DB) ([]*PrimaryStringType, error) {
	in := PrimaryStringType{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &PrimaryStringTypeORM{}, &PrimaryStringType{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []PrimaryStringTypeORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*PrimaryStringType{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type PrimaryStringTypeORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryStringTypeORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]PrimaryStringTypeORM) error
}

// DefaultCreateTestTag executes a basic gorm create call
func DefaultCreateTestTag(ctx context.Context, in *TestTag, db *gorm.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestTagORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTestTag(ctx context.Context, in *TestTag, db *gorm.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TestTagORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TestTagORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TestTagORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TestTagORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTestTag(ctx context.Context, in *TestTag, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TestTagORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TestTagORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTestTagSet(ctx context.Context, in []*TestTag, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TestTagORM{})).(TestTagORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TestTagORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TestTagORM{})).(TestTagORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TestTagORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TestTag, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestTag, *gorm.DB) error
}

// DefaultStrictUpdateTestTag clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestTag(ctx context.Context, in *TestTag, db *gorm.DB) (*TestTag, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTestTag")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TestTagORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterTestTagAssoc := TestTagAssociationORM{}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	filterTestTagAssoc.TestTagId = new(string)
	*filterTestTagAssoc.TestTagId = ormObj.Id
	if err = db.Where(filterTestTagAssoc).Delete(TestTagAssociationORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TestTagORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTestTag executes a basic gorm update call with patch behavior
func DefaultPatchTestTag(ctx context.Context, in *TestTag, updateMask *field_mask.FieldMask, db *gorm.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TestTag
	var err error
	if hook, ok := interface{}(&pbObj).(TestTagWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTestTag(ctx, &TestTag{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TestTagWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTestTag(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TestTagWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTestTag(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TestTagWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TestTagWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TestTag, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestTagWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestTag, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestTagWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestTag, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestTagWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestTag, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTestTag executes a bulk gorm update call with patch behavior
func DefaultPatchSetTestTag(ctx context.Context, objects []*TestTag, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TestTag, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TestTag, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTestTag(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTestTag patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTag(ctx context.Context, patchee *TestTag, patcher *TestTag, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestTag, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedTestTagAssoc bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if !updatedTestTagAssoc && strings.HasPrefix(f, prefix+"TestTagAssoc.") {
			updatedTestTagAssoc = true
			if patcher.TestTagAssoc == nil {
				patchee.TestTagAssoc = nil
				continue
			}
			if patchee.TestTagAssoc == nil {
				patchee.TestTagAssoc = &TestTagAssociation{}
			}
			if o, err := DefaultApplyFieldMaskTestTagAssociation(ctx, patchee.TestTagAssoc, patcher.TestTagAssoc, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"TestTagAssoc.", db); err != nil {
				return nil, err
			} else {
				patchee.TestTagAssoc = o
			}
			continue
		}
		if f == prefix+"TestTagAssoc" {
			updatedTestTagAssoc = true
			patchee.TestTagAssoc = patcher.TestTagAssoc
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestTag executes a gorm list call
func DefaultListTestTag(ctx context.Context, db *gorm.DB) ([]*TestTag, error) {
	in := TestTag{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestTagORM{}, &TestTag{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TestTagORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestTag{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestTagORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestTagORM) error
}

// DefaultCreateTestAssocHandlerDefault executes a basic gorm create call
func DefaultCreateTestAssocHandlerDefault(ctx context.Context, in *TestAssocHandlerDefault, db *gorm.DB) (*TestAssocHandlerDefault, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerDefaultORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTestAssocHandlerDefault(ctx context.Context, in *TestAssocHandlerDefault, db *gorm.DB) (*TestAssocHandlerDefault, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TestAssocHandlerDefaultORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TestAssocHandlerDefaultORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TestAssocHandlerDefaultORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerDefaultORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerDefault(ctx context.Context, in *TestAssocHandlerDefault, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TestAssocHandlerDefaultORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TestAssocHandlerDefaultORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerDefaultSet(ctx context.Context, in []*TestAssocHandlerDefault, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TestAssocHandlerDefaultORM{})).(TestAssocHandlerDefaultORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TestAssocHandlerDefaultORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TestAssocHandlerDefaultORM{})).(TestAssocHandlerDefaultORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TestAssocHandlerDefaultORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TestAssocHandlerDefault, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestAssocHandlerDefault, *gorm.DB) error
}

// DefaultStrictUpdateTestAssocHandlerDefault clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestAssocHandlerDefault(ctx context.Context, in *TestAssocHandlerDefault, db *gorm.DB) (*TestAssocHandlerDefault, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTestAssocHandlerDefault")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TestAssocHandlerDefaultORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterTestTagAssoc := TestTagAssociationORM{}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	filterTestTagAssoc.TestAssocHandlerDefaultId = new(string)
	*filterTestTagAssoc.TestAssocHandlerDefaultId = ormObj.Id
	if err = db.Where(filterTestTagAssoc).Delete(TestTagAssociationORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TestAssocHandlerDefaultORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTestAssocHandlerDefault executes a basic gorm update call with patch behavior
func DefaultPatchTestAssocHandlerDefault(ctx context.Context, in *TestAssocHandlerDefault, updateMask *field_mask.FieldMask, db *gorm.DB) (*TestAssocHandlerDefault, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TestAssocHandlerDefault
	var err error
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerDefaultWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTestAssocHandlerDefault(ctx, &TestAssocHandlerDefault{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerDefaultWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTestAssocHandlerDefault(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerDefaultWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTestAssocHandlerDefault(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TestAssocHandlerDefaultWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TestAssocHandlerDefaultWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TestAssocHandlerDefault, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestAssocHandlerDefault, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestAssocHandlerDefault, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestAssocHandlerDefault, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTestAssocHandlerDefault executes a bulk gorm update call with patch behavior
func DefaultPatchSetTestAssocHandlerDefault(ctx context.Context, objects []*TestAssocHandlerDefault, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TestAssocHandlerDefault, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TestAssocHandlerDefault, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTestAssocHandlerDefault(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTestAssocHandlerDefault patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestAssocHandlerDefault(ctx context.Context, patchee *TestAssocHandlerDefault, patcher *TestAssocHandlerDefault, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestAssocHandlerDefault, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"TestTagAssoc" {
			patchee.TestTagAssoc = patcher.TestTagAssoc
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestAssocHandlerDefault executes a gorm list call
func DefaultListTestAssocHandlerDefault(ctx context.Context, db *gorm.DB) ([]*TestAssocHandlerDefault, error) {
	in := TestAssocHandlerDefault{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestAssocHandlerDefaultORM{}, &TestAssocHandlerDefault{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TestAssocHandlerDefaultORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerDefaultORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestAssocHandlerDefault{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestAssocHandlerDefaultORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerDefaultORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestAssocHandlerDefaultORM) error
}

// DefaultCreateTestAssocHandlerReplace executes a basic gorm create call
func DefaultCreateTestAssocHandlerReplace(ctx context.Context, in *TestAssocHandlerReplace, db *gorm.DB) (*TestAssocHandlerReplace, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerReplaceORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTestAssocHandlerReplace(ctx context.Context, in *TestAssocHandlerReplace, db *gorm.DB) (*TestAssocHandlerReplace, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TestAssocHandlerReplaceORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TestAssocHandlerReplaceORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TestAssocHandlerReplaceORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerReplaceORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerReplace(ctx context.Context, in *TestAssocHandlerReplace, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TestAssocHandlerReplaceORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TestAssocHandlerReplaceORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerReplaceSet(ctx context.Context, in []*TestAssocHandlerReplace, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TestAssocHandlerReplaceORM{})).(TestAssocHandlerReplaceORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TestAssocHandlerReplaceORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TestAssocHandlerReplaceORM{})).(TestAssocHandlerReplaceORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TestAssocHandlerReplaceORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TestAssocHandlerReplace, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestAssocHandlerReplace, *gorm.DB) error
}

// DefaultStrictUpdateTestAssocHandlerReplace clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestAssocHandlerReplace(ctx context.Context, in *TestAssocHandlerReplace, db *gorm.DB) (*TestAssocHandlerReplace, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTestAssocHandlerReplace")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TestAssocHandlerReplaceORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Model(&ormObj).Association("TestTagAssoc").Replace(ormObj.TestTagAssoc); err != nil {
		return nil, err
	}
	ormObj.TestTagAssoc = nil
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TestAssocHandlerReplaceORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTestAssocHandlerReplace executes a basic gorm update call with patch behavior
func DefaultPatchTestAssocHandlerReplace(ctx context.Context, in *TestAssocHandlerReplace, updateMask *field_mask.FieldMask, db *gorm.DB) (*TestAssocHandlerReplace, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TestAssocHandlerReplace
	var err error
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerReplaceWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTestAssocHandlerReplace(ctx, &TestAssocHandlerReplace{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerReplaceWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTestAssocHandlerReplace(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerReplaceWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTestAssocHandlerReplace(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TestAssocHandlerReplaceWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TestAssocHandlerReplaceWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TestAssocHandlerReplace, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestAssocHandlerReplace, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestAssocHandlerReplace, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestAssocHandlerReplace, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTestAssocHandlerReplace executes a bulk gorm update call with patch behavior
func DefaultPatchSetTestAssocHandlerReplace(ctx context.Context, objects []*TestAssocHandlerReplace, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TestAssocHandlerReplace, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TestAssocHandlerReplace, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTestAssocHandlerReplace(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTestAssocHandlerReplace patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestAssocHandlerReplace(ctx context.Context, patchee *TestAssocHandlerReplace, patcher *TestAssocHandlerReplace, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestAssocHandlerReplace, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"TestTagAssoc" {
			patchee.TestTagAssoc = patcher.TestTagAssoc
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestAssocHandlerReplace executes a gorm list call
func DefaultListTestAssocHandlerReplace(ctx context.Context, db *gorm.DB) ([]*TestAssocHandlerReplace, error) {
	in := TestAssocHandlerReplace{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestAssocHandlerReplaceORM{}, &TestAssocHandlerReplace{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TestAssocHandlerReplaceORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerReplaceORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestAssocHandlerReplace{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestAssocHandlerReplaceORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerReplaceORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestAssocHandlerReplaceORM) error
}

// DefaultCreateTestAssocHandlerClear executes a basic gorm create call
func DefaultCreateTestAssocHandlerClear(ctx context.Context, in *TestAssocHandlerClear, db *gorm.DB) (*TestAssocHandlerClear, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerClearORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTestAssocHandlerClear(ctx context.Context, in *TestAssocHandlerClear, db *gorm.DB) (*TestAssocHandlerClear, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TestAssocHandlerClearORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TestAssocHandlerClearORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TestAssocHandlerClearORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerClearORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerClear(ctx context.Context, in *TestAssocHandlerClear, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TestAssocHandlerClearORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TestAssocHandlerClearORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerClearSet(ctx context.Context, in []*TestAssocHandlerClear, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TestAssocHandlerClearORM{})).(TestAssocHandlerClearORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TestAssocHandlerClearORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TestAssocHandlerClearORM{})).(TestAssocHandlerClearORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TestAssocHandlerClearORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TestAssocHandlerClear, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestAssocHandlerClear, *gorm.DB) error
}

// DefaultStrictUpdateTestAssocHandlerClear clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestAssocHandlerClear(ctx context.Context, in *TestAssocHandlerClear, db *gorm.DB) (*TestAssocHandlerClear, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTestAssocHandlerClear")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TestAssocHandlerClearORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Model(&ormObj).Association("TestTagAssoc").Clear(); err != nil {
		return nil, err
	}
	ormObj.TestTagAssoc = nil
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TestAssocHandlerClearORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTestAssocHandlerClear executes a basic gorm update call with patch behavior
func DefaultPatchTestAssocHandlerClear(ctx context.Context, in *TestAssocHandlerClear, updateMask *field_mask.FieldMask, db *gorm.DB) (*TestAssocHandlerClear, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TestAssocHandlerClear
	var err error
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerClearWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTestAssocHandlerClear(ctx, &TestAssocHandlerClear{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerClearWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTestAssocHandlerClear(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerClearWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTestAssocHandlerClear(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TestAssocHandlerClearWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TestAssocHandlerClearWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TestAssocHandlerClear, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestAssocHandlerClear, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestAssocHandlerClear, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestAssocHandlerClear, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTestAssocHandlerClear executes a bulk gorm update call with patch behavior
func DefaultPatchSetTestAssocHandlerClear(ctx context.Context, objects []*TestAssocHandlerClear, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TestAssocHandlerClear, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TestAssocHandlerClear, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTestAssocHandlerClear(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTestAssocHandlerClear patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestAssocHandlerClear(ctx context.Context, patchee *TestAssocHandlerClear, patcher *TestAssocHandlerClear, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestAssocHandlerClear, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"TestTagAssoc" {
			patchee.TestTagAssoc = patcher.TestTagAssoc
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestAssocHandlerClear executes a gorm list call
func DefaultListTestAssocHandlerClear(ctx context.Context, db *gorm.DB) ([]*TestAssocHandlerClear, error) {
	in := TestAssocHandlerClear{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestAssocHandlerClearORM{}, &TestAssocHandlerClear{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TestAssocHandlerClearORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerClearORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestAssocHandlerClear{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestAssocHandlerClearORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerClearORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestAssocHandlerClearORM) error
}

// DefaultCreateTestAssocHandlerAppend executes a basic gorm create call
func DefaultCreateTestAssocHandlerAppend(ctx context.Context, in *TestAssocHandlerAppend, db *gorm.DB) (*TestAssocHandlerAppend, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerAppendORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadTestAssocHandlerAppend(ctx context.Context, in *TestAssocHandlerAppend, db *gorm.DB) (*TestAssocHandlerAppend, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &TestAssocHandlerAppendORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := TestAssocHandlerAppendORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(TestAssocHandlerAppendORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type TestAssocHandlerAppendORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerAppend(ctx context.Context, in *TestAssocHandlerAppend, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&TestAssocHandlerAppendORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type TestAssocHandlerAppendORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeleteTestAssocHandlerAppendSet(ctx context.Context, in []*TestAssocHandlerAppend, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&TestAssocHandlerAppendORM{})).(TestAssocHandlerAppendORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&TestAssocHandlerAppendORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&TestAssocHandlerAppendORM{})).(TestAssocHandlerAppendORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type TestAssocHandlerAppendORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*TestAssocHandlerAppend, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestAssocHandlerAppend, *gorm.DB) error
}

// DefaultStrictUpdateTestAssocHandlerAppend clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestAssocHandlerAppend(ctx context.Context, in *TestAssocHandlerAppend, db *gorm.DB) (*TestAssocHandlerAppend, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdateTestAssocHandlerAppend")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &TestAssocHandlerAppendORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Model(&ormObj).Association("TestTagAssoc").Append(ormObj.TestTagAssoc); err != nil {
		return nil, err
	}
	ormObj.TestTagAssoc = nil
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type TestAssocHandlerAppendORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchTestAssocHandlerAppend executes a basic gorm update call with patch behavior
func DefaultPatchTestAssocHandlerAppend(ctx context.Context, in *TestAssocHandlerAppend, updateMask *field_mask.FieldMask, db *gorm.DB) (*TestAssocHandlerAppend, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj TestAssocHandlerAppend
	var err error
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerAppendWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbReadRes, err := DefaultReadTestAssocHandlerAppend(ctx, &TestAssocHandlerAppend{Id: in.GetId()}, db)
	if err != nil {
		return nil, err
	}
	pbObj = *pbReadRes
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerAppendWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskTestAssocHandlerAppend(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(TestAssocHandlerAppendWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdateTestAssocHandlerAppend(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(TestAssocHandlerAppendWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type TestAssocHandlerAppendWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *TestAssocHandlerAppend, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestAssocHandlerAppend, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestAssocHandlerAppend, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestAssocHandlerAppend, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetTestAssocHandlerAppend executes a bulk gorm update call with patch behavior
func DefaultPatchSetTestAssocHandlerAppend(ctx context.Context, objects []*TestAssocHandlerAppend, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*TestAssocHandlerAppend, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*TestAssocHandlerAppend, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchTestAssocHandlerAppend(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskTestAssocHandlerAppend patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestAssocHandlerAppend(ctx context.Context, patchee *TestAssocHandlerAppend, patcher *TestAssocHandlerAppend, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestAssocHandlerAppend, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if f == prefix+"TestTagAssoc" {
			patchee.TestTagAssoc = patcher.TestTagAssoc
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestAssocHandlerAppend executes a gorm list call
func DefaultListTestAssocHandlerAppend(ctx context.Context, db *gorm.DB) ([]*TestAssocHandlerAppend, error) {
	in := TestAssocHandlerAppend{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestAssocHandlerAppendORM{}, &TestAssocHandlerAppend{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []TestAssocHandlerAppendORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestAssocHandlerAppendORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestAssocHandlerAppend{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestAssocHandlerAppendORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestAssocHandlerAppendORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestAssocHandlerAppendORM) error
}

// DefaultCreateTestTagAssociation executes a basic gorm create call
func DefaultCreateTestTagAssociation(ctx context.Context, in *TestTagAssociation, db *gorm.DB) (*TestTagAssociation, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type TestTagAssociationORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagAssociationORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

// DefaultApplyFieldMaskTestTagAssociation patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTagAssociation(ctx context.Context, patchee *TestTagAssociation, patcher *TestTagAssociation, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*TestTagAssociation, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"SomeField" {
			patchee.SomeField = patcher.SomeField
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestTagAssociation executes a gorm list call
func DefaultListTestTagAssociation(ctx context.Context, db *gorm.DB) ([]*TestTagAssociation, error) {
	in := TestTagAssociation{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &TestTagAssociationORM{}, &TestTagAssociation{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	ormResponse := []TestTagAssociationORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(TestTagAssociationORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*TestTagAssociation{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type TestTagAssociationORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagAssociationORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type TestTagAssociationORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]TestTagAssociationORM) error
}

// DefaultCreatePrimaryIncluded executes a basic gorm create call
func DefaultCreatePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db *gorm.DB) (*PrimaryIncluded, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeCreate_); ok {
		if db, err = hook.BeforeCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Create(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterCreate_); ok {
		if err = hook.AfterCreate_(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryIncludedORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

func DefaultReadPrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db *gorm.DB) (*PrimaryIncluded, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == go_uuid.Nil {
		return nil, errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm1.ApplyFieldSelection(ctx, db, nil, &PrimaryIncludedORM{}); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeReadFind); ok {
		if db, err = hook.BeforeReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	ormResponse := PrimaryIncludedORM{}
	if err = db.Where(&ormObj).First(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormResponse).(PrimaryIncludedORMWithAfterReadFind); ok {
		if err = hook.AfterReadFind(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormResponse.ToPB(ctx)
	return &pbResponse, err
}

type PrimaryIncludedORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == go_uuid.Nil {
		return errors.EmptyIdError
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeDelete_); ok {
		if db, err = hook.BeforeDelete_(ctx, db); err != nil {
			return err
		}
	}
	err = db.Where(&ormObj).Delete(&PrimaryIncludedORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterDelete_); ok {
		err = hook.AfterDelete_(ctx, db)
	}
	return err
}

type PrimaryIncludedORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

func DefaultDeletePrimaryIncludedSet(ctx context.Context, in []*PrimaryIncluded, db *gorm.DB) error {
	if in == nil {
		return errors.NilArgumentError
	}
	var err error
	keys := []go_uuid.UUID{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == go_uuid.Nil {
			return errors.EmptyIdError
		}
		keys = append(keys, ormObj.Id)
	}
	if hook, ok := (interface{}(&PrimaryIncludedORM{})).(PrimaryIncludedORMWithBeforeDeleteSet); ok {
		if db, err = hook.BeforeDeleteSet(ctx, in, db); err != nil {
			return err
		}
	}
	err = db.Where("id in (?)", keys).Delete(&PrimaryIncludedORM{}).Error
	if err != nil {
		return err
	}
	if hook, ok := (interface{}(&PrimaryIncludedORM{})).(PrimaryIncludedORMWithAfterDeleteSet); ok {
		err = hook.AfterDeleteSet(ctx, in, db)
	}
	return err
}

type PrimaryIncludedORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*PrimaryIncluded, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*PrimaryIncluded, *gorm.DB) error
}

// DefaultStrictUpdatePrimaryIncluded clears / replaces / appends first level 1:many children and then executes a gorm update call
func DefaultStrictUpdatePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db *gorm.DB) (*PrimaryIncluded, error) {
	if in == nil {
		return nil, fmt.Errorf("Nil argument to DefaultStrictUpdatePrimaryIncluded")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	var count int64
	lockedRow := &PrimaryIncludedORM{}
	count = db.Model(&ormObj).Set("gorm:query_option", "FOR UPDATE").Where("id=?", ormObj.Id).First(lockedRow).RowsAffected
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeStrictUpdateCleanup); ok {
		if db, err = hook.BeforeStrictUpdateCleanup(ctx, db); err != nil {
			return nil, err
		}
	}
	filterChild := ExternalChildORM{}
	if ormObj.Id == go_uuid.Nil {
		return nil, errors.EmptyIdError
	}
	filterChild.PrimaryIncludedId = new(go_uuid.UUID)
	*filterChild.PrimaryIncludedId = ormObj.Id
	if err = db.Where(filterChild).Delete(ExternalChildORM{}).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeStrictUpdateSave); ok {
		if db, err = hook.BeforeStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	if err = db.Omit().Save(&ormObj).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterStrictUpdateSave); ok {
		if err = hook.AfterStrictUpdateSave(ctx, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := ormObj.ToPB(ctx)
	if err != nil {
		return nil, err
	}
	if count == 0 {
		err = gateway.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

type PrimaryIncludedORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

// DefaultPatchPrimaryIncluded executes a basic gorm update call with patch behavior
func DefaultPatchPrimaryIncluded(ctx context.Context, in *PrimaryIncluded, updateMask *field_mask.FieldMask, db *gorm.DB) (*PrimaryIncluded, error) {
	if in == nil {
		return nil, errors.NilArgumentError
	}
	var pbObj PrimaryIncluded
	var err error
	if hook, ok := interface{}(&pbObj).(PrimaryIncludedWithBeforePatchRead); ok {
		if db, err = hook.BeforePatchRead(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if hook, ok := interface{}(&pbObj).(PrimaryIncludedWithBeforePatchApplyFieldMask); ok {
		if db, err = hook.BeforePatchApplyFieldMask(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	if _, err := DefaultApplyFieldMaskPrimaryIncluded(ctx, &pbObj, in, updateMask, "", db); err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&pbObj).(PrimaryIncludedWithBeforePatchSave); ok {
		if db, err = hook.BeforePatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	pbResponse, err := DefaultStrictUpdatePrimaryIncluded(ctx, &pbObj, db)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(pbResponse).(PrimaryIncludedWithAfterPatchSave); ok {
		if err = hook.AfterPatchSave(ctx, in, updateMask, db); err != nil {
			return nil, err
		}
	}
	return pbResponse, nil
}

type PrimaryIncludedWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *PrimaryIncluded, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *PrimaryIncluded, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *PrimaryIncluded, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *PrimaryIncluded, *field_mask.FieldMask, *gorm.DB) error
}

// DefaultPatchSetPrimaryIncluded executes a bulk gorm update call with patch behavior
func DefaultPatchSetPrimaryIncluded(ctx context.Context, objects []*PrimaryIncluded, updateMasks []*field_mask.FieldMask, db *gorm.DB) ([]*PrimaryIncluded, error) {
	if len(objects) != len(updateMasks) {
		return nil, fmt.Errorf(errors.BadRepeatedFieldMaskTpl, len(updateMasks), len(objects))
	}

	results := make([]*PrimaryIncluded, 0, len(objects))
	for i, patcher := range objects {
		pbResponse, err := DefaultPatchPrimaryIncluded(ctx, patcher, updateMasks[i], db)
		if err != nil {
			return nil, err
		}

		results = append(results, pbResponse)
	}

	return results, nil
}

// DefaultApplyFieldMaskPrimaryIncluded patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryIncluded(ctx context.Context, patchee *PrimaryIncluded, patcher *PrimaryIncluded, updateMask *field_mask.FieldMask, prefix string, db *gorm.DB) (*PrimaryIncluded, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.NilArgumentError
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if !updatedChild && strings.HasPrefix(f, prefix+"Child.") {
			updatedChild = true
			if patcher.Child == nil {
				patchee.Child = nil
				continue
			}
			if patchee.Child == nil {
				patchee.Child = &ExternalChild{}
			}
			if o, err := DefaultApplyFieldMaskExternalChild(ctx, patchee.Child, patcher.Child, &field_mask.FieldMask{Paths: updateMask.Paths[i:]}, prefix+"Child.", db); err != nil {
				return nil, err
			} else {
				patchee.Child = o
			}
			continue
		}
		if f == prefix+"Child" {
			updatedChild = true
			patchee.Child = patcher.Child
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListPrimaryIncluded executes a gorm list call
func DefaultListPrimaryIncluded(ctx context.Context, db *gorm.DB) ([]*PrimaryIncluded, error) {
	in := PrimaryIncluded{}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeListApplyQuery); ok {
		if db, err = hook.BeforeListApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	db, err = gorm1.ApplyCollectionOperators(ctx, db, &PrimaryIncludedORM{}, &PrimaryIncluded{}, nil, nil, nil, nil)
	if err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithBeforeListFind); ok {
		if db, err = hook.BeforeListFind(ctx, db); err != nil {
			return nil, err
		}
	}
	db = db.Where(&ormObj)
	db = db.Order("id")
	ormResponse := []PrimaryIncludedORM{}
	if err := db.Find(&ormResponse).Error; err != nil {
		return nil, err
	}
	if hook, ok := interface{}(&ormObj).(PrimaryIncludedORMWithAfterListFind); ok {
		if err = hook.AfterListFind(ctx, db, &ormResponse); err != nil {
			return nil, err
		}
	}
	pbResponse := []*PrimaryIncluded{}
	for _, responseEntry := range ormResponse {
		temp, err := responseEntry.ToPB(ctx)
		if err != nil {
			return nil, err
		}
		pbResponse = append(pbResponse, &temp)
	}
	return pbResponse, nil
}

type PrimaryIncludedORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}
type PrimaryIncludedORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]PrimaryIncludedORM) error
}