scan

type Debugging struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"level,attr"
	Level int32 `protobuf:"varint,10,opt,name=Level,proto3" json:"Level,omitempty" xml:"level,attr"`
	// contains filtered or unexported fields
}

type DebuggingORM struct {
	Id    string `gorm:"type:uuid;primary_key"`
	Level int32
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type DebuggingWithAfterToORM interface {
	AfterToORM(context.Context, *DebuggingORM) error
}

type DebuggingWithAfterToPB interface {
	AfterToPB(context.Context, *Debugging) error
}

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

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

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

type DebuggingWithBeforeToORM interface {
	BeforeToORM(context.Context, *DebuggingORM) error
}

type DebuggingWithBeforeToPB interface {
	BeforeToPB(context.Context, *Debugging) error
}

type Finished struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"time,attr"
	Time int64 `protobuf:"varint,10,opt,name=Time,proto3" json:"Time,omitempty" xml:"time,attr"`
	// @gotags: xml:"timestr,attr"
	TimeStr string `protobuf:"bytes,11,opt,name=TimeStr,proto3" json:"TimeStr,omitempty" xml:"timestr,attr"`
	// @gotags: xml:"elapsed,attr"
	Elapsed float32 `protobuf:"fixed32,12,opt,name=Elapsed,proto3" json:"Elapsed,omitempty" xml:"elapsed,attr"`
	// @gotags: xml:"summary,attr"
	Summary string `protobuf:"bytes,13,opt,name=Summary,proto3" json:"Summary,omitempty" xml:"summary,attr"`
	// @gotags: xml:"exit,attr"
	Exit string `protobuf:"bytes,14,opt,name=Exit,proto3" json:"Exit,omitempty" xml:"exit,attr"`
	// @gotags: xml:"errormsg,attr"
	ErrorMsg string `protobuf:"bytes,15,opt,name=ErrorMsg,proto3" json:"ErrorMsg,omitempty" xml:"errormsg,attr"`
	// contains filtered or unexported fields
}

type FinishedORM struct {
	Elapsed  float32
	ErrorMsg string
	Exit     string
	Id       string `gorm:"type:uuid;primary_key"`
	StatsId  *string
	Summary  string
	Time     int64
	TimeStr  string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type FinishedWithAfterToORM interface {
	AfterToORM(context.Context, *FinishedORM) error
}

type FinishedWithAfterToPB interface {
	AfterToPB(context.Context, *Finished) error
}

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

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

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

type FinishedWithBeforeToORM interface {
	BeforeToORM(context.Context, *FinishedORM) error
}

type FinishedWithBeforeToPB interface {
	BeforeToPB(context.Context, *Finished) error
}

type HostStats struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"up,attr"
	Up int32 `protobuf:"varint,10,opt,name=Up,proto3" json:"Up,omitempty" xml:"up,attr"`
	// @gotags: xml:"down,attr"
	Down int32 `protobuf:"varint,11,opt,name=Down,proto3" json:"Down,omitempty" xml:"down,attr"`
	// @gotags: xml:"total,attr"
	Total int32 `protobuf:"varint,12,opt,name=Total,proto3" json:"Total,omitempty" xml:"total,attr"`
	// contains filtered or unexported fields
}

type HostStatsORM struct {
	Down    int32
	Id      string `gorm:"type:uuid;primary_key"`
	StatsId *string
	Total   int32
	Up      int32
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type HostStatsWithAfterToORM interface {
	AfterToORM(context.Context, *HostStatsORM) error
}

type HostStatsWithAfterToPB interface {
	AfterToPB(context.Context, *HostStats) error
}

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

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

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

type HostStatsWithBeforeToORM interface {
	BeforeToORM(context.Context, *HostStatsORM) error
}

type HostStatsWithBeforeToPB interface {
	BeforeToPB(context.Context, *HostStats) error
}

type Info struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"numservices,attr"
	NumServices int32 `protobuf:"varint,10,opt,name=NumServices,proto3" json:"NumServices,omitempty" xml:"numservices,attr"`
	// @gotags: xml:"protocol,attr"
	Protocol string `protobuf:"bytes,11,opt,name=Protocol,proto3" json:"Protocol,omitempty" xml:"protocol,attr"`
	// @gotags: xml:"scanflags,attr"
	ScanFlags string `protobuf:"bytes,12,opt,name=ScanFlags,proto3" json:"ScanFlags,omitempty" xml:"scanflags,attr"`
	// @gotags: xml:"services,attr"
	Services string `protobuf:"bytes,13,opt,name=Services,proto3" json:"Services,omitempty" xml:"services,attr"`
	// @gotags: xml:"type,attr"
	Type string `protobuf:"bytes,14,opt,name=Type,proto3" json:"Type,omitempty" xml:"type,attr"`
	// contains filtered or unexported fields
}

type InfoORM struct {
	Id          string `gorm:"type:uuid;primary_key"`
	NumServices int32
	Protocol    string
	ScanFlags   string
	Services    string
	Type        string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type InfoWithAfterToORM interface {
	AfterToORM(context.Context, *InfoORM) error
}

type InfoWithAfterToPB interface {
	AfterToPB(context.Context, *Info) error
}

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

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

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

type InfoWithBeforeToORM interface {
	BeforeToORM(context.Context, *InfoORM) error
}

type InfoWithBeforeToPB interface {
	BeforeToPB(context.Context, *Info) error
}

type Result struct {
	Id      string           `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	Host    *host.Host       `protobuf:"bytes,2,opt,name=Host,proto3" json:"Host,omitempty"`
	Address *network.Address `protobuf:"bytes,3,opt,name=Address,proto3" json:"Address,omitempty"`
	Port    *host.Port       `protobuf:"bytes,4,opt,name=Port,proto3" json:"Port,omitempty"`
	Service *network.Service `protobuf:"bytes,5,opt,name=Service,proto3" json:"Service,omitempty"`
	// Data - The output data of a scan for a given protocol/service,
	// eg. if the scan is an SSH one, this will contain the SSH result.
	// If you pass your service-specific results in there, be sure to
	// add a branch case in the Go scan package, in which you populate
	// the entity tree with it.
	Data string `protobuf:"bytes,10,opt,name=Data,proto3" json:"Data,omitempty"`
	// contains filtered or unexported fields
}

type ResultORM struct {
	Address   *network.AddressORM `gorm:"foreignkey:AddressId;association_foreignkey:Id"`
	AddressId *string
	Data      string
	Host      *host.HostORM `gorm:"foreignkey:HostId;association_foreignkey:Id"`
	HostId    *string
	Id        string        `gorm:"type:uuid;primary_key"`
	Port      *host.PortORM `gorm:"foreignkey:PortId;association_foreignkey:Id"`
	PortId    *string
	Service   *network.ServiceORM `gorm:"foreignkey:ServiceId;association_foreignkey:Id"`
	ServiceId *string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type ResultWithAfterToORM interface {
	AfterToORM(context.Context, *ResultORM) error
}

type ResultWithAfterToPB interface {
	AfterToPB(context.Context, *Result) error
}

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

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

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

type ResultWithBeforeToORM interface {
	BeforeToORM(context.Context, *ResultORM) error
}

type ResultWithBeforeToPB interface {
	BeforeToPB(context.Context, *Result) error
}

type Run struct {

	// @gotags: display:"ID" readonly:"true"
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty" display:"ID" readonly:"true"`
	// @gotags: display:"Created at" readonly:"true" xml:"-"
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,4,opt,name=CreatedAt,proto3" json:"CreatedAt,omitempty" display:"Created at" readonly:"true" xml:"-"`
	// @gotags: display:"Updated at" readonly:"true" xml:"-"
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=UpdatedAt,proto3" json:"UpdatedAt,omitempty" display:"Updated at" readonly:"true" xml:"-"`
	// An optional session from which the scan runs.
	SessionId string `protobuf:"bytes,8,opt,name=SessionId,proto3" json:"SessionId,omitempty"`
	// An optional host (on which is a session/beacon) from which the scan runs.
	HostId string `protobuf:"bytes,9,opt,name=HostId,proto3" json:"HostId,omitempty"`
	// Nmap --------------------------------
	// @gotags: xml:"args,attr"
	Args string `protobuf:"bytes,10,opt,name=Args,proto3" json:"Args,omitempty" xml:"args,attr"`
	// @gotags: xml:"profile_name,attr"
	ProfileName string `protobuf:"bytes,11,opt,name=ProfileName,proto3" json:"ProfileName,omitempty" xml:"profile_name,attr"`
	// @gotags: xml:"scanner,attr"
	Scanner string `protobuf:"bytes,12,opt,name=Scanner,proto3" json:"Scanner,omitempty" xml:"scanner,attr"`
	// @gotags: xml:"startstr,attr"
	StartStr string `protobuf:"bytes,13,opt,name=StartStr,proto3" json:"StartStr,omitempty" xml:"startstr,attr"`
	// @gotags: xml:"version,attr"
	Version string `protobuf:"bytes,14,opt,name=Version,proto3" json:"Version,omitempty" xml:"version,attr"`
	// @gotags: xml:"xmloutputversion,attr"
	XMLOutputVersion string `protobuf:"bytes,15,opt,name=XMLOutputVersion,proto3" json:"XMLOutputVersion,omitempty" xml:"xmloutputversion,attr"`
	// @gotags: xml:"debugging"
	Debugging *Debugging `protobuf:"bytes,16,opt,name=Debugging,proto3" json:"Debugging,omitempty" xml:"debugging"`
	// @gotags: xml:"runstats"
	Stats *Stats `protobuf:"bytes,17,opt,name=Stats,proto3" json:"Stats,omitempty" xml:"runstats"`
	// @gotags: xml:"scaninfo"
	Info *Info `protobuf:"bytes,18,opt,name=Info,proto3" json:"Info,omitempty" xml:"scaninfo"`
	// @gotags: xml:"start,attr"
	Start int64 `protobuf:"varint,19,opt,name=Start,proto3" json:"Start,omitempty" xml:"start,attr"`
	// @gotags: xml:"verbose"
	Verbose *Verbose `protobuf:"bytes,20,opt,name=Verbose,proto3" json:"Verbose,omitempty" xml:"verbose"`
	// @gotags: xml:"host"
	Hosts []*host.Host `protobuf:"bytes,21,rep,name=Hosts,proto3" json:"Hosts,omitempty" xml:"host"`
	// @gotags: xml:"prescript>script"
	PreScripts []*nmap.Script `protobuf:"bytes,22,rep,name=PreScripts,proto3" json:"PreScripts,omitempty" xml:"prescript>script"`
	// @gotags: xml:"postscript>script"
	PostScripts []*nmap.Script `protobuf:"bytes,23,rep,name=PostScripts,proto3" json:"PostScripts,omitempty" xml:"postscript>script"`
	// @gotags: xml:"target"
	Targets []*Target `protobuf:"bytes,24,rep,name=Targets,proto3" json:"Targets,omitempty" xml:"target"`
	// @gotags: xml:"taskbegin"
	Begin []*Task `protobuf:"bytes,25,rep,name=Begin,proto3" json:"Begin,omitempty" xml:"taskbegin"`
	// @gotags: xml:"taskprogress"
	Progress []*TaskProgress `protobuf:"bytes,26,rep,name=Progress,proto3" json:"Progress,omitempty" xml:"taskprogress"`
	// @gotags: xml:"taskend"
	End        []*Task  `protobuf:"bytes,27,rep,name=End,proto3" json:"End,omitempty" xml:"taskend"`
	NmapErrors []string `protobuf:"bytes,28,rep,name=NmapErrors,proto3" json:"NmapErrors,omitempty"`
	RawXML     string   `protobuf:"bytes,30,opt,name=RawXML,proto3" json:"RawXML,omitempty"`
	// Results - Generally, scans other than Nmap can produce
	// asynchronous results, which has a few implications:
	//   - We can make the scan push its results to caller
	//   - We must however build any entity tree ourselves,
	//     with most of the nmap population not done for us,
	//     for things like traceroutes.
	//
	// The scan.Run has methods and internal logic to deal
	// with populating and/or pushing and/or validating results
	// as they come during a scan.
	Results []*Result `protobuf:"bytes,40,rep,name=Results,proto3" json:"Results,omitempty"`
	// contains filtered or unexported fields
}

type RunORM struct {
	Args             string
	Begin            []*TaskORM `` /* 134-byte string literal not displayed */
	CreatedAt        *time.Time
	Debugging        *DebuggingORM `gorm:"foreignkey:DebuggingId;association_foreignkey:Id"`
	DebuggingId      *string
	End              []*TaskORM `` /* 132-byte string literal not displayed */
	HostId           string
	Hosts            []*host.HostORM `` /* 133-byte string literal not displayed */
	Id               string          `gorm:"type:uuid;primary_key"`
	Info             *InfoORM        `gorm:"foreignkey:InfoId;association_foreignkey:Id"`
	InfoId           *string
	PostScripts      []*nmap.ScriptORM `` /* 142-byte string literal not displayed */
	PreScripts       []*nmap.ScriptORM `` /* 141-byte string literal not displayed */
	ProfileName      string
	Progress         []*TaskProgressORM `` /* 151-byte string literal not displayed */
	RawXML           string
	Results          []*ResultORM `` /* 137-byte string literal not displayed */
	Scanner          string
	SessionId        string
	Start            int64
	StartStr         string
	Stats            *StatsORM `gorm:"foreignkey:StatsId;association_foreignkey:Id"`
	StatsId          *string
	Targets          []*TargetORM `` /* 137-byte string literal not displayed */
	UpdatedAt        *time.Time
	Verbose          *VerboseORM `gorm:"foreignkey:VerboseId;association_foreignkey:Id"`
	VerboseId        *string
	Version          string
	XMLOutputVersion string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type RunWithAfterToORM interface {
	AfterToORM(context.Context, *RunORM) error
}

type RunWithAfterToPB interface {
	AfterToPB(context.Context, *Run) error
}

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

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

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

type RunWithBeforeToORM interface {
	BeforeToORM(context.Context, *RunORM) error
}

type RunWithBeforeToPB interface {
	BeforeToPB(context.Context, *Run) error
}

type Stats struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"finished"
	Finished *Finished `protobuf:"bytes,10,opt,name=Finished,proto3" json:"Finished,omitempty" xml:"finished"`
	// @gotags: xml:"hosts"
	Hosts *HostStats `protobuf:"bytes,11,opt,name=Hosts,proto3" json:"Hosts,omitempty" xml:"hosts"`
	// contains filtered or unexported fields
}

type StatsORM struct {
	Finished *FinishedORM  `gorm:"foreignkey:StatsId;association_foreignkey:Id"`
	Hosts    *HostStatsORM `gorm:"foreignkey:StatsId;association_foreignkey:Id"`
	Id       string        `gorm:"type:uuid;primary_key"`
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type StatsWithAfterToORM interface {
	AfterToORM(context.Context, *StatsORM) error
}

type StatsWithAfterToPB interface {
	AfterToPB(context.Context, *Stats) error
}

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

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

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

type StatsWithBeforeToORM interface {
	BeforeToORM(context.Context, *StatsORM) error
}

type StatsWithBeforeToPB interface {
	BeforeToPB(context.Context, *Stats) error
}

type Target struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// Input ---------------------------
	Address string `protobuf:"bytes,5,opt,name=Address,proto3" json:"Address,omitempty"`
	Domain  string `protobuf:"bytes,6,opt,name=Domain,proto3" json:"Domain,omitempty"`
	Tag     string `protobuf:"bytes,7,opt,name=Tag,proto3" json:"Tag,omitempty"`
	Port    uint32 `protobuf:"varint,8,opt,name=Port,proto3" json:"Port,omitempty"`
	// Output (Nmap) -------------------
	// @gotags: xml:"specification,attr"
	Specification string `protobuf:"bytes,10,opt,name=Specification,proto3" json:"Specification,omitempty" xml:"specification,attr"`
	// @gotags: xml:"status,attr"
	Status string `protobuf:"bytes,11,opt,name=Status,proto3" json:"Status,omitempty" xml:"status,attr"`
	// @gotags: xml:"reason,attr"
	Reason string `protobuf:"bytes,12,opt,name=Reason,proto3" json:"Reason,omitempty" xml:"reason,attr"`
	// contains filtered or unexported fields
}

type TargetORM struct {
	Address       string
	Domain        string
	Id            string `gorm:"type:uuid;primary_key"`
	Port          uint32
	Reason        string
	Specification string
	Status        string
	Tag           string
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type TargetWithAfterToORM interface {
	AfterToORM(context.Context, *TargetORM) error
}

type TargetWithAfterToPB interface {
	AfterToPB(context.Context, *Target) error
}

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

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

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

type TargetWithBeforeToORM interface {
	BeforeToORM(context.Context, *TargetORM) error
}

type TargetWithBeforeToPB interface {
	BeforeToPB(context.Context, *Target) error
}

type Task struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"time,attr"
	Time int64 `protobuf:"varint,10,opt,name=Time,proto3" json:"Time,omitempty" xml:"time,attr"`
	// @gotags: xml:"task,attr"
	Task string `protobuf:"bytes,11,opt,name=Task,proto3" json:"Task,omitempty" xml:"task,attr"`
	// @gotags: xml:"extrainfo,attr"
	ExtraInfo string `protobuf:"bytes,12,opt,name=ExtraInfo,proto3" json:"ExtraInfo,omitempty" xml:"extrainfo,attr"`
	// contains filtered or unexported fields
}

type TaskORM struct {
	ExtraInfo string
	Id        string `gorm:"type:uuid;primary_key"`
	Task      string
	Time      int64
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

type TaskProgress struct {
	Id string `protobuf:"bytes,1,opt,name=Id,proto3" json:"Id,omitempty"`
	// @gotags: xml:"percent,attr"
	Percent float32 `protobuf:"fixed32,10,opt,name=Percent,proto3" json:"Percent,omitempty" xml:"percent,attr"`
	// @gotags: xml:"remaining,attr"
	Remaining int32 `protobuf:"varint,11,opt,name=Remaining,proto3" json:"Remaining,omitempty" xml:"remaining,attr"`
	// @gotags: xml:"task,attr"
	Task string `protobuf:"bytes,12,opt,name=Task,proto3" json:"Task,omitempty" xml:"task,attr"`
	// @gotags: xml:"etc,attr"
	Etc int64 `protobuf:"varint,13,opt,name=Etc,proto3" json:"Etc,omitempty" xml:"etc,attr"`
	// @gotags: xml:"time,attr"
	Time int64 `protobuf:"varint,14,opt,name=Time,proto3" json:"Time,omitempty" xml:"time,attr"`
	// contains filtered or unexported fields
}