demo_types.pb.gorm.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: example/feature_demo/demo_types.proto

package example

import context "context"
import errors "errors"
import strings "strings"
import time "time"

import auth1 "github.com/infobloxopen/atlas-app-toolkit/auth"
import field_mask1 "google.golang.org/genproto/protobuf/field_mask"
import gateway1 "github.com/infobloxopen/atlas-app-toolkit/gateway"
import go_uuid1 "github.com/satori/go.uuid"
import gorm1 "github.com/jinzhu/gorm"
import gorm2 "github.com/infobloxopen/atlas-app-toolkit/gorm"
import postgres1 "github.com/jinzhu/gorm/dialects/postgres"
import pq1 "github.com/lib/pq"
import ptypes1 "github.com/golang/protobuf/ptypes"
import types1 "github.com/infobloxopen/protoc-gen-gorm/types"

import fmt "fmt"
import math "math"
import google_protobuf1 "github.com/golang/protobuf/ptypes/wrappers"
import _ "github.com/golang/protobuf/ptypes/empty"
import _ "github.com/golang/protobuf/ptypes/timestamp"
import user "github.com/infobloxopen/protoc-gen-gorm/example/user"

// Reference imports to suppress errors if they are not otherwise used.
var _ = fmt.Errorf
var _ = math.Inf

type TestTypesORM struct {
	ANestedObjectTypeWithIDId *uint32
	Array                     pq1.StringArray
	Array2                    pq1.StringArray
	BecomesInt                string
	CreatedAt                 time.Time
	JsonField                 *postgres1.Jsonb `gorm:"type:jsonb"`
	NullableUuid              *go_uuid1.UUID   `gorm:"type:uuid"`
	OptionalString            *string
	ThingsTypeWithIDId        *uint32
	TypeWithIdId              uint32
	Uuid                      go_uuid1.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_uuid1.FromString(m.Uuid.Value)
		if err != nil {
			return to, err
		}
	} else {
		to.Uuid = go_uuid1.Nil
	}
	if m.CreatedAt != nil {
		if to.CreatedAt, err = ptypes1.Timestamp(m.CreatedAt); err != nil {
			return to, err
		}
	}
	to.TypeWithIdId = m.TypeWithIdId
	if m.JsonField != nil {
		to.JsonField = &postgres1.Jsonb{[]byte(m.JsonField.Value)}
	}
	if m.NullableUuid != nil {
		tempUUID, uErr := go_uuid1.FromString(m.NullableUuid.Value)
		if uErr != nil {
			return to, uErr
		}
		to.NullableUuid = &tempUUID
	}
	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 = &google_protobuf1.StringValue{Value: *m.OptionalString}
	}
	to.BecomesInt = TestTypesStatus(TestTypesStatus_value[m.BecomesInt])
	to.Uuid = &types1.UUID{Value: m.Uuid.String()}
	if to.CreatedAt, err = ptypes1.TimestampProto(m.CreatedAt); err != nil {
		return to, err
	}
	to.TypeWithIdId = m.TypeWithIdId
	if m.JsonField != nil {
		to.JsonField = &types1.JSONValue{Value: string(m.JsonField.RawMessage)}
	}
	if m.NullableUuid != nil {
		to.NullableUuid = &types1.UUIDValue{Value: m.NullableUuid.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;association_foreignkey:Id"`
	Address           *types1.Inet  `gorm:"type:inet"`
	Id                uint32
	IntPointId        *uint32
	Ip                string          `gorm:"column:ip_addr"`
	MultiAccountTypes []*JoinTable    `gorm:"foreignkey:TypeWithIDID"`
	Point             *IntPointORM    `gorm:"foreignkey:IntPointId;association_foreignkey:Id"`
	SecretInt         int32           `gorm:"-"`
	TagSizeTest       string          `gorm:"size:512"`
	TagTest           float32         `gorm:"type:float;precision:6"`
	Things            []*TestTypesORM `gorm:"foreignkey:ThingsTypeWithIDId;association_foreignkey:Id"`
	User              *user.UserORM   `gorm:"foreignkey:UserId;association_foreignkey: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 = types1.ParseInet(m.Address.Value); err != nil {
			return to, err
		}
	}
	to.TagTest = m.TagTest
	to.TagSizeTest = m.TagSizeTest
	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 = &types1.InetValue{Value: m.Address.String()}
	}
	to.TagTest = m.TagTest
	to.TagSizeTest = m.TagSizeTest
	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 := auth1.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 := auth1.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;association_foreignkey:Id"`
	Id    *go_uuid1.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_uuid1.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 = &types1.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;association_foreignkey: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;association_foreignkey:Id;preload:false"`
}

// 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 TestTagAssociationORM struct {
	SomeField 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;association_foreignkey:Id"`
	Id    go_uuid1.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 *gorm1.DB) (*TestTypes, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateTestTypes")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTypesORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultApplyFieldMaskTestTypes patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTypes(ctx context.Context, patchee *TestTypes, patcher *TestTypes, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*TestTypes, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskTestTypes must be non-nil")
	}
	var err error
	for _, f := range updateMask.Paths {
		if f == prefix+"ApiOnlyString" {
			patchee.ApiOnlyString = patcher.ApiOnlyString
			continue
		}
		if f == prefix+"Numbers" {
			patchee.Numbers = patcher.Numbers
			continue
		}
		if f == prefix+"OptionalString" {
			patchee.OptionalString = patcher.OptionalString
			continue
		}
		if f == prefix+"BecomesInt" {
			patchee.BecomesInt = patcher.BecomesInt
			continue
		}
		if f == prefix+"Nothingness" {
			patchee.Nothingness = patcher.Nothingness
			continue
		}
		if f == prefix+"Uuid" {
			patchee.Uuid = patcher.Uuid
			continue
		}
		if f == prefix+"CreatedAt" {
			patchee.CreatedAt = patcher.CreatedAt
			continue
		}
		if f == prefix+"TypeWithIdId" {
			patchee.TypeWithIdId = patcher.TypeWithIdId
			continue
		}
		if f == prefix+"JsonField" {
			patchee.JsonField = patcher.JsonField
			continue
		}
		if f == prefix+"NullableUuid" {
			patchee.NullableUuid = patcher.NullableUuid
			continue
		}
	}
	if err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTestTypes executes a gorm list call
func DefaultListTestTypes(ctx context.Context, db *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTypesORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TestTypesORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]TestTypesORM) error
}

// DefaultCreateTypeWithID executes a basic gorm create call
func DefaultCreateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateTypeWithID")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultReadTypeWithID executes a basic gorm read call
func DefaultReadTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultReadTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.New("DefaultReadTypeWithID requires a non-zero primary key")
	}
	if hook, ok := interface{}(&ormObj).(TypeWithIDORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm1.DB) error
}

func DefaultDeleteTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.New("A non-zero ID value is required for a delete call")
	}
	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, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithAfterDelete interface {
	AfterDelete(context.Context, *gorm1.DB) error
}

func DefaultDeleteTypeWithIDSet(ctx context.Context, in []*TypeWithID, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteTypeWithIDSet")
	}
	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.New("A non-zero ID value is required for a delete call")
		}
		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, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TypeWithID, *gorm1.DB) error
}

// DefaultStrictUpdateTypeWithID clears first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTypeWithID(ctx context.Context, in *TypeWithID, db *gorm1.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.New("Can't do overwriting update with no Id value for TypeWithIDORM")
	}
	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.New("Can't do overwriting update with no Id value for TypeWithIDORM")
	}
	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.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 = gateway1.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

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

// DefaultPatchTypeWithID executes a basic gorm update call with patch behavior
func DefaultPatchTypeWithID(ctx context.Context, in *TypeWithID, updateMask *field_mask1.FieldMask, db *gorm1.DB) (*TypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultPatchTypeWithID")
	}
	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_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TypeWithID, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TypeWithID, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TypeWithID, *field_mask1.FieldMask, *gorm1.DB) error
}

// DefaultApplyFieldMaskTypeWithID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTypeWithID(ctx context.Context, patchee *TypeWithID, patcher *TypeWithID, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*TypeWithID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskTypeWithID must be non-nil")
	}
	var err error
	var updatedANestedObject bool
	var updatedPoint bool
	var updatedUser bool
	var updatedSyntheticField 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 strings.HasPrefix(f, prefix+"ANestedObject.") && !updatedANestedObject {
			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_mask1.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 strings.HasPrefix(f, prefix+"Point.") && !updatedPoint {
			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_mask1.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 strings.HasPrefix(f, prefix+"User.") && !updatedUser {
			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_mask1.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 strings.HasPrefix(f, prefix+"SyntheticField.") && !updatedSyntheticField {
			if patcher.SyntheticField == nil {
				patchee.SyntheticField = nil
				continue
			}
			if patchee.SyntheticField == nil {
				patchee.SyntheticField = &APIOnlyType{}
			}
			childMask := &field_mask1.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 := gorm2.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 err != nil {
		return nil, err
	}
	return patchee, nil
}

// DefaultListTypeWithID executes a gorm list call
func DefaultListTypeWithID(ctx context.Context, db *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TypeWithIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]TypeWithIDORM) error
}

// DefaultCreateMultiaccountTypeWithID executes a basic gorm create call
func DefaultCreateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm1.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateMultiaccountTypeWithID")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultReadMultiaccountTypeWithID executes a basic gorm read call
func DefaultReadMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm1.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultReadMultiaccountTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == 0 {
		return nil, errors.New("DefaultReadMultiaccountTypeWithID requires a non-zero primary key")
	}
	if hook, ok := interface{}(&ormObj).(MultiaccountTypeWithIDORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm1.DB) error
}

func DefaultDeleteMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteMultiaccountTypeWithID")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == 0 {
		return errors.New("A non-zero ID value is required for a delete call")
	}
	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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterDelete interface {
	AfterDelete(context.Context, *gorm1.DB) error
}

func DefaultDeleteMultiaccountTypeWithIDSet(ctx context.Context, in []*MultiaccountTypeWithID, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteMultiaccountTypeWithIDSet")
	}
	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.New("A non-zero ID value is required for a delete call")
		}
		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 := auth1.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*MultiaccountTypeWithID, *gorm1.DB) error
}

// DefaultStrictUpdateMultiaccountTypeWithID clears first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, db *gorm1.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 := auth1.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.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 = gateway1.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

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

// DefaultPatchMultiaccountTypeWithID executes a basic gorm update call with patch behavior
func DefaultPatchMultiaccountTypeWithID(ctx context.Context, in *MultiaccountTypeWithID, updateMask *field_mask1.FieldMask, db *gorm1.DB) (*MultiaccountTypeWithID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultPatchMultiaccountTypeWithID")
	}
	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_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *MultiaccountTypeWithID, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *MultiaccountTypeWithID, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *MultiaccountTypeWithID, *field_mask1.FieldMask, *gorm1.DB) error
}

// DefaultApplyFieldMaskMultiaccountTypeWithID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskMultiaccountTypeWithID(ctx context.Context, patchee *MultiaccountTypeWithID, patcher *MultiaccountTypeWithID, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*MultiaccountTypeWithID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskMultiaccountTypeWithID must be non-nil")
	}
	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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]MultiaccountTypeWithIDORM) error
}

// DefaultCreateMultiaccountTypeWithoutID executes a basic gorm create call
func DefaultCreateMultiaccountTypeWithoutID(ctx context.Context, in *MultiaccountTypeWithoutID, db *gorm1.DB) (*MultiaccountTypeWithoutID, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateMultiaccountTypeWithoutID")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithoutIDORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultApplyFieldMaskMultiaccountTypeWithoutID patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskMultiaccountTypeWithoutID(ctx context.Context, patchee *MultiaccountTypeWithoutID, patcher *MultiaccountTypeWithoutID, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*MultiaccountTypeWithoutID, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskMultiaccountTypeWithoutID must be non-nil")
	}
	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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithoutIDORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type MultiaccountTypeWithoutIDORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]MultiaccountTypeWithoutIDORM) error
}

// DefaultCreatePrimaryUUIDType executes a basic gorm create call
func DefaultCreatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm1.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreatePrimaryUUIDType")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultReadPrimaryUUIDType executes a basic gorm read call
func DefaultReadPrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm1.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultReadPrimaryUUIDType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == nil || *ormObj.Id == go_uuid1.Nil {
		return nil, errors.New("DefaultReadPrimaryUUIDType requires a non-zero primary key")
	}
	if hook, ok := interface{}(&ormObj).(PrimaryUUIDTypeORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm1.DB) error
}

func DefaultDeletePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeletePrimaryUUIDType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == nil || *ormObj.Id == go_uuid1.Nil {
		return errors.New("A non-zero ID value is required for a delete call")
	}
	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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithAfterDelete interface {
	AfterDelete(context.Context, *gorm1.DB) error
}

func DefaultDeletePrimaryUUIDTypeSet(ctx context.Context, in []*PrimaryUUIDType, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeletePrimaryUUIDTypeSet")
	}
	var err error
	keys := []*go_uuid1.UUID{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == nil || *ormObj.Id == go_uuid1.Nil {
			return errors.New("A non-zero ID value is required for a delete call")
		}
		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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*PrimaryUUIDType, *gorm1.DB) error
}

// DefaultStrictUpdatePrimaryUUIDType clears first level 1:many children and then executes a gorm update call
func DefaultStrictUpdatePrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, db *gorm1.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_uuid1.Nil {
		return nil, errors.New("Can't do overwriting update with no Id value for PrimaryUUIDTypeORM")
	}
	filterChild.PrimaryUUIDTypeId = new(go_uuid1.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.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 = gateway1.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

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

// DefaultPatchPrimaryUUIDType executes a basic gorm update call with patch behavior
func DefaultPatchPrimaryUUIDType(ctx context.Context, in *PrimaryUUIDType, updateMask *field_mask1.FieldMask, db *gorm1.DB) (*PrimaryUUIDType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultPatchPrimaryUUIDType")
	}
	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_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *PrimaryUUIDType, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *PrimaryUUIDType, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *PrimaryUUIDType, *field_mask1.FieldMask, *gorm1.DB) error
}

// DefaultApplyFieldMaskPrimaryUUIDType patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryUUIDType(ctx context.Context, patchee *PrimaryUUIDType, patcher *PrimaryUUIDType, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*PrimaryUUIDType, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskPrimaryUUIDType must be non-nil")
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if strings.HasPrefix(f, prefix+"Child.") && !updatedChild {
			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_mask1.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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryUUIDTypeORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]PrimaryUUIDTypeORM) error
}

// DefaultCreatePrimaryStringType executes a basic gorm create call
func DefaultCreatePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm1.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreatePrimaryStringType")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultReadPrimaryStringType executes a basic gorm read call
func DefaultReadPrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm1.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultReadPrimaryStringType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.New("DefaultReadPrimaryStringType requires a non-zero primary key")
	}
	if hook, ok := interface{}(&ormObj).(PrimaryStringTypeORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm1.DB) error
}

func DefaultDeletePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeletePrimaryStringType")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.New("A non-zero ID value is required for a delete call")
	}
	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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithAfterDelete interface {
	AfterDelete(context.Context, *gorm1.DB) error
}

func DefaultDeletePrimaryStringTypeSet(ctx context.Context, in []*PrimaryStringType, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeletePrimaryStringTypeSet")
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.New("A non-zero ID value is required for a delete call")
		}
		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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*PrimaryStringType, *gorm1.DB) error
}

// DefaultStrictUpdatePrimaryStringType clears first level 1:many children and then executes a gorm update call
func DefaultStrictUpdatePrimaryStringType(ctx context.Context, in *PrimaryStringType, db *gorm1.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.New("Can't do overwriting update with no Id value for PrimaryStringTypeORM")
	}
	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.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 = gateway1.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

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

// DefaultPatchPrimaryStringType executes a basic gorm update call with patch behavior
func DefaultPatchPrimaryStringType(ctx context.Context, in *PrimaryStringType, updateMask *field_mask1.FieldMask, db *gorm1.DB) (*PrimaryStringType, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultPatchPrimaryStringType")
	}
	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_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *PrimaryStringType, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *PrimaryStringType, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *PrimaryStringType, *field_mask1.FieldMask, *gorm1.DB) error
}

// DefaultApplyFieldMaskPrimaryStringType patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryStringType(ctx context.Context, patchee *PrimaryStringType, patcher *PrimaryStringType, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*PrimaryStringType, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskPrimaryStringType must be non-nil")
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if strings.HasPrefix(f, prefix+"Child.") && !updatedChild {
			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_mask1.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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryStringTypeORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]PrimaryStringTypeORM) error
}

// DefaultCreateTestTag executes a basic gorm create call
func DefaultCreateTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateTestTag")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultReadTestTag executes a basic gorm read call
func DefaultReadTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultReadTestTag")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return nil, err
	}
	if ormObj.Id == "" {
		return nil, errors.New("DefaultReadTestTag requires a non-zero primary key")
	}
	if hook, ok := interface{}(&ormObj).(TestTagORMWithBeforeReadApplyQuery); ok {
		if db, err = hook.BeforeReadApplyQuery(ctx, db); err != nil {
			return nil, err
		}
	}
	if db, err = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm1.DB) error
}

func DefaultDeleteTestTag(ctx context.Context, in *TestTag, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteTestTag")
	}
	ormObj, err := in.ToORM(ctx)
	if err != nil {
		return err
	}
	if ormObj.Id == "" {
		return errors.New("A non-zero ID value is required for a delete call")
	}
	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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithAfterDelete interface {
	AfterDelete(context.Context, *gorm1.DB) error
}

func DefaultDeleteTestTagSet(ctx context.Context, in []*TestTag, db *gorm1.DB) error {
	if in == nil {
		return errors.New("Nil argument to DefaultDeleteTestTagSet")
	}
	var err error
	keys := []string{}
	for _, obj := range in {
		ormObj, err := obj.ToORM(ctx)
		if err != nil {
			return err
		}
		if ormObj.Id == "" {
			return errors.New("A non-zero ID value is required for a delete call")
		}
		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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*TestTag, *gorm1.DB) error
}

// DefaultStrictUpdateTestTag clears first level 1:many children and then executes a gorm update call
func DefaultStrictUpdateTestTag(ctx context.Context, in *TestTag, db *gorm1.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.New("Can't do overwriting update with no Id value for TestTagORM")
	}
	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.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 = gateway1.SetCreated(ctx, "")
	}
	return &pbResponse, err
}

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

// DefaultPatchTestTag executes a basic gorm update call with patch behavior
func DefaultPatchTestTag(ctx context.Context, in *TestTag, updateMask *field_mask1.FieldMask, db *gorm1.DB) (*TestTag, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultPatchTestTag")
	}
	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_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *TestTag, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *TestTag, *field_mask1.FieldMask, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *TestTag, *field_mask1.FieldMask, *gorm1.DB) error
}

// DefaultApplyFieldMaskTestTag patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTag(ctx context.Context, patchee *TestTag, patcher *TestTag, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*TestTag, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskTestTag must be non-nil")
	}
	var err error
	var updatedTestTagAssoc bool
	for i, f := range updateMask.Paths {
		if f == prefix+"Id" {
			patchee.Id = patcher.Id
			continue
		}
		if strings.HasPrefix(f, prefix+"TestTagAssoc.") && !updatedTestTagAssoc {
			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_mask1.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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]TestTagORM) error
}

// DefaultCreateTestTagAssociation executes a basic gorm create call
func DefaultCreateTestTagAssociation(ctx context.Context, in *TestTagAssociation, db *gorm1.DB) (*TestTagAssociation, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreateTestTagAssociation")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagAssociationORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultApplyFieldMaskTestTagAssociation patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskTestTagAssociation(ctx context.Context, patchee *TestTagAssociation, patcher *TestTagAssociation, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*TestTagAssociation, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskTestTagAssociation must be non-nil")
	}
	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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagAssociationORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type TestTagAssociationORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]TestTagAssociationORM) error
}

// DefaultCreatePrimaryIncluded executes a basic gorm create call
func DefaultCreatePrimaryIncluded(ctx context.Context, in *PrimaryIncluded, db *gorm1.DB) (*PrimaryIncluded, error) {
	if in == nil {
		return nil, errors.New("Nil argument to DefaultCreatePrimaryIncluded")
	}
	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.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryIncludedORMWithAfterCreate interface {
	AfterCreate(context.Context, *gorm1.DB) error
}

// DefaultApplyFieldMaskPrimaryIncluded patches an pbObject with patcher according to a field mask.
func DefaultApplyFieldMaskPrimaryIncluded(ctx context.Context, patchee *PrimaryIncluded, patcher *PrimaryIncluded, updateMask *field_mask1.FieldMask, prefix string, db *gorm1.DB) (*PrimaryIncluded, error) {
	if patcher == nil {
		return nil, nil
	} else if patchee == nil {
		return nil, errors.New("Patchee inputs to DefaultApplyFieldMaskPrimaryIncluded must be non-nil")
	}
	var err error
	var updatedChild bool
	for i, f := range updateMask.Paths {
		if strings.HasPrefix(f, prefix+"Child.") && !updatedChild {
			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_mask1.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 *gorm1.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 = gorm2.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, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryIncludedORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm1.DB) (*gorm1.DB, error)
}
type PrimaryIncludedORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm1.DB, *[]PrimaryIncludedORM) error
}