credential

type Core struct {
	Id        string                 `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
	// Origin - The origin of this Credential.
	Origin *Origin `protobuf:"bytes,10,opt,name=Origin,proto3" json:"Origin,omitempty"`
	// Private - The credential.Private either gathered from Realm,
	// or used to credential.ReplayableHash authenticate into the realm.
	Private *Private `protobuf:"bytes,11,opt,name=Private,proto3" json:"Private,omitempty"`
	// Public - The credential.Public gathered from Realm.
	Public *Public `protobuf:"bytes,12,opt,name=Public,proto3" json:"Public,omitempty"`
	// Realm - credential.Realm where Private and/or Public was gathered
	// and/or the credential.Realm to which Private and/or Public can be
	// used to authenticate.
	Realm *Realm `protobuf:"bytes,13,opt,name=Realm,proto3" json:"Realm,omitempty"`
	// repeated Login Logins = 14;
	LoginsCount int32 `protobuf:"varint,8,opt,name=LoginsCount,proto3" json:"LoginsCount,omitempty"`
	// contains filtered or unexported fields
}

type CoreORM struct {
	CreatedAt   *time.Time
	Id          string `gorm:"type:uuid;primary_key"`
	LoginId     *string
	LoginsCount int32
	Origin      *OriginORM  `gorm:"not null;foreignkey:CoreId;association_foreignkey:Id"`
	Private     *PrivateORM `gorm:"foreignkey:CoreId;association_foreignkey:Id"`
	Public      *PublicORM  `gorm:"foreignkey:CoreId;association_foreignkey:Id"`
	Realm       *RealmORM   `gorm:"foreignkey:CoreId;association_foreignkey:Id"`
	UpdatedAt   *time.Time
}

type CoreORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type CoreORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Core, *gorm.DB) error
}

type CoreORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type CoreORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]CoreORM) error
}

type CoreORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type CoreORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type CoreORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Core, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type CoreWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Core, *field_mask.FieldMask, *gorm.DB) error
}

type CoreWithAfterToORM interface {
	AfterToORM(context.Context, *CoreORM) error
}

type CoreWithAfterToPB interface {
	AfterToPB(context.Context, *Core) error
}

type CoreWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Core, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type CoreWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Core, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type CoreWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Core, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type CoreWithBeforeToORM interface {
	BeforeToORM(context.Context, *CoreORM) error
}

type CoreWithBeforeToPB interface {
	BeforeToPB(context.Context, *Core) error
}

type Login struct {
	Id        string                 `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
	// string CoreId = 10 [(gorm.field).tag = {type:"uuid" primary_key: true}];
	LastAttemptedAt *timestamppb.Timestamp `protobuf:"bytes,11,opt,name=LastAttemptedAt,proto3" json:"LastAttemptedAt,omitempty"`
	AccessLevel     string                 `protobuf:"bytes,20,opt,name=AccessLevel,proto3" json:"AccessLevel,omitempty"`
	Status          LoginStatus            `protobuf:"varint,21,opt,name=Status,proto3,enum=credential.LoginStatus" json:"Status,omitempty"`
	// Core - The credential.Core used to authenticate to Service
	Core *Core `protobuf:"bytes,13,opt,name=Core,proto3" json:"Core,omitempty"`
	// Service - The service that either accepted the credential.Core as valid, invalid,
	// or on which the credential.Core should be tested to see if it is valid.
	Service *network.Service `protobuf:"bytes,22,opt,name=Service,proto3" json:"Service,omitempty"`
	// The host on which Service runs
	HostId string `protobuf:"bytes,23,opt,name=HostId,proto3" json:"HostId,omitempty"`
	// contains filtered or unexported fields
}

type LoginORM struct {
	AccessLevel     string
	Core            *CoreORM `gorm:"not null;foreignkey:LoginId;association_foreignkey:Id"`
	CreatedAt       *time.Time
	HostId          string `gorm:"type:uuid;not null"`
	Id              string `gorm:"type:uuid;primary_key"`
	LastAttemptedAt *time.Time
	Service         *network.ServiceORM `gorm:"foreignkey:ServiceId;association_foreignkey:Id"`
	ServiceId       *string
	Status          int32
	UpdatedAt       *time.Time
}

type LoginORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type LoginORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Login, *gorm.DB) error
}

type LoginORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type LoginORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]LoginORM) error
}

type LoginORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type LoginORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type LoginORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Login, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type LoginStatus int32

type LoginWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Login, *field_mask.FieldMask, *gorm.DB) error
}

type LoginWithAfterToORM interface {
	AfterToORM(context.Context, *LoginORM) error
}

type LoginWithAfterToPB interface {
	AfterToPB(context.Context, *Login) error
}

type LoginWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Login, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type LoginWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Login, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type LoginWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Login, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type LoginWithBeforeToORM interface {
	BeforeToORM(context.Context, *LoginORM) error
}

type LoginWithBeforeToPB interface {
	BeforeToPB(context.Context, *Login) error
}

type Origin struct {
	Id        string                 `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty"`
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty"`
	// Common
	SessionId string     `protobuf:"bytes,10,opt,name=SessionId,proto3" json:"SessionId,omitempty"`
	Type      OriginType `protobuf:"varint,11,opt,name=Type,proto3,enum=credential.OriginType" json:"Type,omitempty"`
	// Origin Import
	// Filename - The `File.basename` of the file from which the credential.Cores were imported.
	// Because only a basename is available, a Filename may be used more than once for the same task.
	Filename string `protobuf:"bytes,20,opt,name=Filename,proto3" json:"Filename,omitempty"`
	// Origin CrackedPassword
	Cracker string `protobuf:"bytes,30,opt,name=Cracker,proto3" json:"Cracker,omitempty"` // The name of the cracking tool
	// Origin Service
	Service *network.Service `protobuf:"bytes,40,opt,name=Service,proto3" json:"Service,omitempty"`
	// contains filtered or unexported fields
}

type OriginORM struct {
	CoreId    *string
	Cracker   string
	CreatedAt *time.Time
	Filename  string
	Id        string              `gorm:"type:uuid;primary_key"`
	Service   *network.ServiceORM `gorm:"foreignkey:ServiceId;association_foreignkey:Id"`
	ServiceId *string
	SessionId string
	Type      int32
	UpdatedAt *time.Time
}

type OriginORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type OriginORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Origin, *gorm.DB) error
}

type OriginORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type OriginORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]OriginORM) error
}

type OriginORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type OriginORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type OriginORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Origin, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type OriginType int32

type OriginWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Origin, *field_mask.FieldMask, *gorm.DB) error
}

type OriginWithAfterToORM interface {
	AfterToORM(context.Context, *OriginORM) error
}

type OriginWithAfterToPB interface {
	AfterToPB(context.Context, *Origin) error
}

type OriginWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Origin, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type OriginWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Origin, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type OriginWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Origin, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type OriginWithBeforeToORM interface {
	BeforeToORM(context.Context, *OriginORM) error
}

type OriginWithBeforeToPB interface {
	BeforeToPB(context.Context, *Origin) error
}

type Private struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: display:"Created at" readonly:"true"
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty" display:"Created at" readonly:"true"`
	// @gotags: display:"Updated at" readonly:"true"
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty" display:"Updated at" readonly:"true"`
	// @gotags: display:"Type" readonly:"true"
	Type PrivateType `protobuf:"varint,10,opt,name=Type,proto3,enum=credential.PrivateType" json:"Type,omitempty" display:"Type" readonly:"true"`
	// No data passed into Maltego at this point.
	Data string `protobuf:"bytes,11,opt,name=Data,proto3" json:"Data,omitempty"`
	// @gotags: display:"JTR Format" readonly:"true"
	JTRFormat string `protobuf:"bytes,12,opt,name=JTRFormat,proto3" json:"JTRFormat,omitempty" display:"JTR Format" readonly:"true"`
	// contains filtered or unexported fields
}

type PrivateORM struct {
	CoreId    *string
	CreatedAt *time.Time
	Data      string
	Id        string `gorm:"type:uuid;primary_key"`
	JTRFormat string
	Type      int32
	UpdatedAt *time.Time
}

type PrivateORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type PrivateORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Private, *gorm.DB) error
}

type PrivateORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type PrivateORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]PrivateORM) error
}

type PrivateORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type PrivateORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type PrivateORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Private, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PrivateType int32

type PrivateWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Private, *field_mask.FieldMask, *gorm.DB) error
}

type PrivateWithAfterToORM interface {
	AfterToORM(context.Context, *PrivateORM) error
}

type PrivateWithAfterToPB interface {
	AfterToPB(context.Context, *Private) error
}

type PrivateWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Private, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PrivateWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Private, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PrivateWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Private, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PrivateWithBeforeToORM interface {
	BeforeToORM(context.Context, *PrivateORM) error
}

type PrivateWithBeforeToPB interface {
	BeforeToPB(context.Context, *Private) error
}

type Public struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: display:"Created at" readonly:"true"
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty" display:"Created at" readonly:"true"`
	// @gotags: display:"Updated at" readonly:"true"
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty" display:"Updated at" readonly:"true"`
	// @gotags: display:"Type" readonly:"true"
	Type PublicType `protobuf:"varint,10,opt,name=Type,proto3,enum=credential.PublicType" json:"Type,omitempty" display:"Type" readonly:"true"`
	// @gotags: display:"Username" readonly:"true"
	Username string `protobuf:"bytes,11,opt,name=Username,proto3" json:"Username,omitempty" display:"Username" readonly:"true"`
	// Data - When the Public credential is a cryptographic key/certificate
	// rather than a username, the key/certificate data is stored in this field.
	// @gotags: display:"Data" readonly:"true"
	Data string `protobuf:"bytes,12,opt,name=Data,proto3" json:"Data,omitempty" display:"Data" readonly:"true"`
	// Claims - Some public credentials, such as JSON Web Tokens,
	// can bear claims, which are a list of key-value pairs. These
	// claims are stored as the bytes of a JSON-marshalled map[string]interface{}
	// A method is provided for credentials to get this map.
	// @gotags: display:"Claims" readonly:"true"
	Claims string `protobuf:"bytes,13,opt,name=Claims,proto3" json:"Claims,omitempty" display:"Claims" readonly:"true"`
	// contains filtered or unexported fields
}

type PublicORM struct {
	Claims    string
	CoreId    *string
	CreatedAt *time.Time
	Data      string
	Id        string `gorm:"type:uuid;primary_key"`
	Type      int32
	UpdatedAt *time.Time
	Username  string
}

type PublicORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type PublicORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Public, *gorm.DB) error
}

type PublicORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type PublicORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]PublicORM) error
}

type PublicORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type PublicORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type PublicORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Public, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type PublicType int32

type PublicWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Public, *field_mask.FieldMask, *gorm.DB) error
}

type PublicWithAfterToORM interface {
	AfterToORM(context.Context, *PublicORM) error
}

type PublicWithAfterToPB interface {
	AfterToPB(context.Context, *Public) error
}

type PublicWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Public, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PublicWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Public, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PublicWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Public, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type PublicWithBeforeToORM interface {
	BeforeToORM(context.Context, *PublicORM) error
}

type PublicWithBeforeToPB interface {
	BeforeToPB(context.Context, *Public) error
}

type Realm struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: display:"Created at" readonly:"true"
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty" display:"Created at" readonly:"true"`
	// @gotags: display:"Updated at" readonly:"true"
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty" display:"Updated at" readonly:"true"`
	// @gotags: display:"Key"
	Key string `protobuf:"bytes,10,opt,name=Key,proto3" json:"Key,omitempty" display:"Key"`
	// @gotags: display:"Value"
	Value string `protobuf:"bytes,11,opt,name=Value,proto3" json:"Value,omitempty" display:"Value"`
	// contains filtered or unexported fields
}

type RealmORM struct {
	CoreId    *string
	CreatedAt *time.Time
	Id        string `gorm:"type:uuid;primary_key"`
	Key       string
	UpdatedAt *time.Time
	Value     string
}

type RealmORMWithAfterCreate_ interface {
	AfterCreate_(context.Context, *gorm.DB) error
}

type RealmORMWithAfterDeleteSet interface {
	AfterDeleteSet(context.Context, []*Realm, *gorm.DB) error
}

type RealmORMWithAfterDelete_ interface {
	AfterDelete_(context.Context, *gorm.DB) error
}

type RealmORMWithAfterListFind interface {
	AfterListFind(context.Context, *gorm.DB, *[]RealmORM) error
}

type RealmORMWithAfterReadFind interface {
	AfterReadFind(context.Context, *gorm.DB) error
}

type RealmORMWithAfterStrictUpdateSave interface {
	AfterStrictUpdateSave(context.Context, *gorm.DB) error
}

type RealmORMWithBeforeCreate_ interface {
	BeforeCreate_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeDeleteSet interface {
	BeforeDeleteSet(context.Context, []*Realm, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeDelete_ interface {
	BeforeDelete_(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeListApplyQuery interface {
	BeforeListApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeListFind interface {
	BeforeListFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeReadApplyQuery interface {
	BeforeReadApplyQuery(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeReadFind interface {
	BeforeReadFind(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeStrictUpdateCleanup interface {
	BeforeStrictUpdateCleanup(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmORMWithBeforeStrictUpdateSave interface {
	BeforeStrictUpdateSave(context.Context, *gorm.DB) (*gorm.DB, error)
}

type RealmWithAfterPatchSave interface {
	AfterPatchSave(context.Context, *Realm, *field_mask.FieldMask, *gorm.DB) error
}

type RealmWithAfterToORM interface {
	AfterToORM(context.Context, *RealmORM) error
}

type RealmWithAfterToPB interface {
	AfterToPB(context.Context, *Realm) error
}

type RealmWithBeforePatchApplyFieldMask interface {
	BeforePatchApplyFieldMask(context.Context, *Realm, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type RealmWithBeforePatchRead interface {
	BeforePatchRead(context.Context, *Realm, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type RealmWithBeforePatchSave interface {
	BeforePatchSave(context.Context, *Realm, *field_mask.FieldMask, *gorm.DB) (*gorm.DB, error)
}

type RealmWithBeforeToORM interface {
	BeforeToORM(context.Context, *RealmORM) error
}

type RealmWithBeforeToPB interface {
	BeforeToPB(context.Context, *Realm) error
}