Make it possible to submit nuisance reports

2026-01-08 17:48:43 +00:00 · 2026-01-08 17:48:43 +00:00 · fc10e3e95d
commit fc10e3e95d
parent a162781f89
14 changed files with 3446 additions and 24 deletions
--- a/db/dberrors/publicreport.nuisance.bob.go
+++ b/db/dberrors/publicreport.nuisance.bob.go
@ -0,0 +1,26 @@
+// Code generated by BobGen psql v0.0.4-0.20260105020634-53e08d840e47+dirty. DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package dberrors
+
+var PublicreportNuisanceErrors = &publicreportNuisanceErrors{
+	ErrUniqueNuisancePkey: &UniqueConstraintError{
+		schema:  "publicreport",
+		table:   "nuisance",
+		columns: []string{"id"},
+		s:       "nuisance_pkey",
+	},
+
+	ErrUniqueNuisancePublicIdKey: &UniqueConstraintError{
+		schema:  "publicreport",
+		table:   "nuisance",
+		columns: []string{"public_id"},
+		s:       "nuisance_public_id_key",
+	},
+}
+
+type publicreportNuisanceErrors struct {
+	ErrUniqueNuisancePkey *UniqueConstraintError
+
+	ErrUniqueNuisancePublicIdKey *UniqueConstraintError
+}
--- a/db/dbinfo/publicreport.nuisance.bob.go
+++ b/db/dbinfo/publicreport.nuisance.bob.go
@ -0,0 +1,352 @@
+// Code generated by BobGen psql v0.0.4-0.20260105020634-53e08d840e47+dirty. DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package dbinfo
+
+import "github.com/aarondl/opt/null"
+
+var PublicreportNuisances = Table[
+	publicreportNuisanceColumns,
+	publicreportNuisanceIndexes,
+	publicreportNuisanceForeignKeys,
+	publicreportNuisanceUniques,
+	publicreportNuisanceChecks,
+]{
+	Schema: "publicreport",
+	Name:   "nuisance",
+	Columns: publicreportNuisanceColumns{
+		ID: column{
+			Name:      "id",
+			DBType:    "integer",
+			Default:   "nextval('publicreport.nuisance_id_seq'::regclass)",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		AdditionalInfo: column{
+			Name:      "additional_info",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		Created: column{
+			Name:      "created",
+			DBType:    "timestamp without time zone",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		Duration: column{
+			Name:      "duration",
+			DBType:    "publicreport.nuisancedurationtype",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		Email: column{
+			Name:      "email",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		InspectionType: column{
+			Name:      "inspection_type",
+			DBType:    "publicreport.nuisanceinspectiontype",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		Location: column{
+			Name:      "location",
+			DBType:    "publicreport.nuisancelocationtype",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		PreferredDateRange: column{
+			Name:      "preferred_date_range",
+			DBType:    "publicreport.nuisancepreferreddaterangetype",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		PreferredTime: column{
+			Name:      "preferred_time",
+			DBType:    "publicreport.nuisancepreferredtimetype",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		RequestCall: column{
+			Name:      "request_call",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		Severity: column{
+			Name:      "severity",
+			DBType:    "smallint",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		SourceContainer: column{
+			Name:      "source_container",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		SourceDescription: column{
+			Name:      "source_description",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		SourceRoof: column{
+			Name:      "source_roof",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		SourceStagnant: column{
+			Name:      "source_stagnant",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		TimeOfDayDay: column{
+			Name:      "time_of_day_day",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		TimeOfDayEarly: column{
+			Name:      "time_of_day_early",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		TimeOfDayEvening: column{
+			Name:      "time_of_day_evening",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		TimeOfDayNight: column{
+			Name:      "time_of_day_night",
+			DBType:    "boolean",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		PublicID: column{
+			Name:      "public_id",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		ReporterAddress: column{
+			Name:      "reporter_address",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		ReporterEmail: column{
+			Name:      "reporter_email",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		ReporterName: column{
+			Name:      "reporter_name",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+		ReporterPhone: column{
+			Name:      "reporter_phone",
+			DBType:    "text",
+			Default:   "",
+			Comment:   "",
+			Nullable:  false,
+			Generated: false,
+			AutoIncr:  false,
+		},
+	},
+	Indexes: publicreportNuisanceIndexes{
+		NuisancePkey: index{
+			Type: "btree",
+			Name: "nuisance_pkey",
+			Columns: []indexColumn{
+				{
+					Name:         "id",
+					Desc:         null.FromCond(false, true),
+					IsExpression: false,
+				},
+			},
+			Unique:        true,
+			Comment:       "",
+			NullsFirst:    []bool{false},
+			NullsDistinct: false,
+			Where:         "",
+			Include:       []string{},
+		},
+		NuisancePublicIDKey: index{
+			Type: "btree",
+			Name: "nuisance_public_id_key",
+			Columns: []indexColumn{
+				{
+					Name:         "public_id",
+					Desc:         null.FromCond(false, true),
+					IsExpression: false,
+				},
+			},
+			Unique:        true,
+			Comment:       "",
+			NullsFirst:    []bool{false},
+			NullsDistinct: false,
+			Where:         "",
+			Include:       []string{},
+		},
+	},
+	PrimaryKey: &constraint{
+		Name:    "nuisance_pkey",
+		Columns: []string{"id"},
+		Comment: "",
+	},
+
+	Uniques: publicreportNuisanceUniques{
+		NuisancePublicIDKey: constraint{
+			Name:    "nuisance_public_id_key",
+			Columns: []string{"public_id"},
+			Comment: "",
+		},
+	},
+
+	Comment: "",
+}
+
+type publicreportNuisanceColumns struct {
+	ID                 column
+	AdditionalInfo     column
+	Created            column
+	Duration           column
+	Email              column
+	InspectionType     column
+	Location           column
+	PreferredDateRange column
+	PreferredTime      column
+	RequestCall        column
+	Severity           column
+	SourceContainer    column
+	SourceDescription  column
+	SourceRoof         column
+	SourceStagnant     column
+	TimeOfDayDay       column
+	TimeOfDayEarly     column
+	TimeOfDayEvening   column
+	TimeOfDayNight     column
+	PublicID           column
+	ReporterAddress    column
+	ReporterEmail      column
+	ReporterName       column
+	ReporterPhone      column
+}
+
+func (c publicreportNuisanceColumns) AsSlice() []column {
+	return []column{
+		c.ID, c.AdditionalInfo, c.Created, c.Duration, c.Email, c.InspectionType, c.Location, c.PreferredDateRange, c.PreferredTime, c.RequestCall, c.Severity, c.SourceContainer, c.SourceDescription, c.SourceRoof, c.SourceStagnant, c.TimeOfDayDay, c.TimeOfDayEarly, c.TimeOfDayEvening, c.TimeOfDayNight, c.PublicID, c.ReporterAddress, c.ReporterEmail, c.ReporterName, c.ReporterPhone,
+	}
+}
+
+type publicreportNuisanceIndexes struct {
+	NuisancePkey        index
+	NuisancePublicIDKey index
+}
+
+func (i publicreportNuisanceIndexes) AsSlice() []index {
+	return []index{
+		i.NuisancePkey, i.NuisancePublicIDKey,
+	}
+}
+
+type publicreportNuisanceForeignKeys struct{}
+
+func (f publicreportNuisanceForeignKeys) AsSlice() []foreignKey {
+	return []foreignKey{}
+}
+
+type publicreportNuisanceUniques struct {
+	NuisancePublicIDKey constraint
+}
+
+func (u publicreportNuisanceUniques) AsSlice() []constraint {
+	return []constraint{
+		u.NuisancePublicIDKey,
+	}
+}
+
+type publicreportNuisanceChecks struct{}
+
+func (c publicreportNuisanceChecks) AsSlice() []check {
+	return []check{}
+}
--- a/db/enums/enums.bob.go
+++ b/db/enums/enums.bob.go
@ -477,3 +477,416 @@ func (e *Notificationtype) Scan(value any) error {

 	return nil
 }
+
+// Enum values for PublicreportNuisancedurationtype
+const (
+	PublicreportNuisancedurationtypeNone        PublicreportNuisancedurationtype = "none"
+	PublicreportNuisancedurationtypeJustNoticed PublicreportNuisancedurationtype = "just-noticed"
+	PublicreportNuisancedurationtypeFewDays     PublicreportNuisancedurationtype = "few-days"
+	PublicreportNuisancedurationtype12Weeks     PublicreportNuisancedurationtype = "1-2-weeks"
+	PublicreportNuisancedurationtype24Weeks     PublicreportNuisancedurationtype = "2-4-weeks"
+	PublicreportNuisancedurationtype13Months    PublicreportNuisancedurationtype = "1-3-months"
+	PublicreportNuisancedurationtypeSeasonal    PublicreportNuisancedurationtype = "seasonal"
+)
+
+func AllPublicreportNuisancedurationtype() []PublicreportNuisancedurationtype {
+	return []PublicreportNuisancedurationtype{
+		PublicreportNuisancedurationtypeNone,
+		PublicreportNuisancedurationtypeJustNoticed,
+		PublicreportNuisancedurationtypeFewDays,
+		PublicreportNuisancedurationtype12Weeks,
+		PublicreportNuisancedurationtype24Weeks,
+		PublicreportNuisancedurationtype13Months,
+		PublicreportNuisancedurationtypeSeasonal,
+	}
+}
+
+type PublicreportNuisancedurationtype string
+
+func (e PublicreportNuisancedurationtype) String() string {
+	return string(e)
+}
+
+func (e PublicreportNuisancedurationtype) Valid() bool {
+	switch e {
+	case PublicreportNuisancedurationtypeNone,
+		PublicreportNuisancedurationtypeJustNoticed,
+		PublicreportNuisancedurationtypeFewDays,
+		PublicreportNuisancedurationtype12Weeks,
+		PublicreportNuisancedurationtype24Weeks,
+		PublicreportNuisancedurationtype13Months,
+		PublicreportNuisancedurationtypeSeasonal:
+		return true
+	default:
+		return false
+	}
+}
+
+// useful when testing in other packages
+func (e PublicreportNuisancedurationtype) All() []PublicreportNuisancedurationtype {
+	return AllPublicreportNuisancedurationtype()
+}
+
+func (e PublicreportNuisancedurationtype) MarshalText() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancedurationtype) UnmarshalText(text []byte) error {
+	return e.Scan(text)
+}
+
+func (e PublicreportNuisancedurationtype) MarshalBinary() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancedurationtype) UnmarshalBinary(data []byte) error {
+	return e.Scan(data)
+}
+
+func (e PublicreportNuisancedurationtype) Value() (driver.Value, error) {
+	return string(e), nil
+}
+
+func (e *PublicreportNuisancedurationtype) Scan(value any) error {
+	switch x := value.(type) {
+	case string:
+		*e = PublicreportNuisancedurationtype(x)
+	case []byte:
+		*e = PublicreportNuisancedurationtype(x)
+	case nil:
+		return fmt.Errorf("cannot nil into PublicreportNuisancedurationtype")
+	default:
+		return fmt.Errorf("cannot scan type %T: %v", value, value)
+	}
+
+	if !e.Valid() {
+		return fmt.Errorf("invalid PublicreportNuisancedurationtype value: %s", *e)
+	}
+
+	return nil
+}
+
+// Enum values for PublicreportNuisanceinspectiontype
+const (
+	PublicreportNuisanceinspectiontypeNeighborhood PublicreportNuisanceinspectiontype = "neighborhood"
+	PublicreportNuisanceinspectiontypeProperty     PublicreportNuisanceinspectiontype = "property"
+)
+
+func AllPublicreportNuisanceinspectiontype() []PublicreportNuisanceinspectiontype {
+	return []PublicreportNuisanceinspectiontype{
+		PublicreportNuisanceinspectiontypeNeighborhood,
+		PublicreportNuisanceinspectiontypeProperty,
+	}
+}
+
+type PublicreportNuisanceinspectiontype string
+
+func (e PublicreportNuisanceinspectiontype) String() string {
+	return string(e)
+}
+
+func (e PublicreportNuisanceinspectiontype) Valid() bool {
+	switch e {
+	case PublicreportNuisanceinspectiontypeNeighborhood,
+		PublicreportNuisanceinspectiontypeProperty:
+		return true
+	default:
+		return false
+	}
+}
+
+// useful when testing in other packages
+func (e PublicreportNuisanceinspectiontype) All() []PublicreportNuisanceinspectiontype {
+	return AllPublicreportNuisanceinspectiontype()
+}
+
+func (e PublicreportNuisanceinspectiontype) MarshalText() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisanceinspectiontype) UnmarshalText(text []byte) error {
+	return e.Scan(text)
+}
+
+func (e PublicreportNuisanceinspectiontype) MarshalBinary() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisanceinspectiontype) UnmarshalBinary(data []byte) error {
+	return e.Scan(data)
+}
+
+func (e PublicreportNuisanceinspectiontype) Value() (driver.Value, error) {
+	return string(e), nil
+}
+
+func (e *PublicreportNuisanceinspectiontype) Scan(value any) error {
+	switch x := value.(type) {
+	case string:
+		*e = PublicreportNuisanceinspectiontype(x)
+	case []byte:
+		*e = PublicreportNuisanceinspectiontype(x)
+	case nil:
+		return fmt.Errorf("cannot nil into PublicreportNuisanceinspectiontype")
+	default:
+		return fmt.Errorf("cannot scan type %T: %v", value, value)
+	}
+
+	if !e.Valid() {
+		return fmt.Errorf("invalid PublicreportNuisanceinspectiontype value: %s", *e)
+	}
+
+	return nil
+}
+
+// Enum values for PublicreportNuisancelocationtype
+const (
+	PublicreportNuisancelocationtypeNone       PublicreportNuisancelocationtype = "none"
+	PublicreportNuisancelocationtypeFrontYard  PublicreportNuisancelocationtype = "front-yard"
+	PublicreportNuisancelocationtypeBackyard   PublicreportNuisancelocationtype = "backyard"
+	PublicreportNuisancelocationtypePatio      PublicreportNuisancelocationtype = "patio"
+	PublicreportNuisancelocationtypeGarden     PublicreportNuisancelocationtype = "garden"
+	PublicreportNuisancelocationtypePoolArea   PublicreportNuisancelocationtype = "pool-area"
+	PublicreportNuisancelocationtypeThroughout PublicreportNuisancelocationtype = "throughout"
+	PublicreportNuisancelocationtypeIndoors    PublicreportNuisancelocationtype = "indoors"
+	PublicreportNuisancelocationtypeOther      PublicreportNuisancelocationtype = "other"
+)
+
+func AllPublicreportNuisancelocationtype() []PublicreportNuisancelocationtype {
+	return []PublicreportNuisancelocationtype{
+		PublicreportNuisancelocationtypeNone,
+		PublicreportNuisancelocationtypeFrontYard,
+		PublicreportNuisancelocationtypeBackyard,
+		PublicreportNuisancelocationtypePatio,
+		PublicreportNuisancelocationtypeGarden,
+		PublicreportNuisancelocationtypePoolArea,
+		PublicreportNuisancelocationtypeThroughout,
+		PublicreportNuisancelocationtypeIndoors,
+		PublicreportNuisancelocationtypeOther,
+	}
+}
+
+type PublicreportNuisancelocationtype string
+
+func (e PublicreportNuisancelocationtype) String() string {
+	return string(e)
+}
+
+func (e PublicreportNuisancelocationtype) Valid() bool {
+	switch e {
+	case PublicreportNuisancelocationtypeNone,
+		PublicreportNuisancelocationtypeFrontYard,
+		PublicreportNuisancelocationtypeBackyard,
+		PublicreportNuisancelocationtypePatio,
+		PublicreportNuisancelocationtypeGarden,
+		PublicreportNuisancelocationtypePoolArea,
+		PublicreportNuisancelocationtypeThroughout,
+		PublicreportNuisancelocationtypeIndoors,
+		PublicreportNuisancelocationtypeOther:
+		return true
+	default:
+		return false
+	}
+}
+
+// useful when testing in other packages
+func (e PublicreportNuisancelocationtype) All() []PublicreportNuisancelocationtype {
+	return AllPublicreportNuisancelocationtype()
+}
+
+func (e PublicreportNuisancelocationtype) MarshalText() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancelocationtype) UnmarshalText(text []byte) error {
+	return e.Scan(text)
+}
+
+func (e PublicreportNuisancelocationtype) MarshalBinary() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancelocationtype) UnmarshalBinary(data []byte) error {
+	return e.Scan(data)
+}
+
+func (e PublicreportNuisancelocationtype) Value() (driver.Value, error) {
+	return string(e), nil
+}
+
+func (e *PublicreportNuisancelocationtype) Scan(value any) error {
+	switch x := value.(type) {
+	case string:
+		*e = PublicreportNuisancelocationtype(x)
+	case []byte:
+		*e = PublicreportNuisancelocationtype(x)
+	case nil:
+		return fmt.Errorf("cannot nil into PublicreportNuisancelocationtype")
+	default:
+		return fmt.Errorf("cannot scan type %T: %v", value, value)
+	}
+
+	if !e.Valid() {
+		return fmt.Errorf("invalid PublicreportNuisancelocationtype value: %s", *e)
+	}
+
+	return nil
+}
+
+// Enum values for PublicreportNuisancepreferreddaterangetype
+const (
+	PublicreportNuisancepreferreddaterangetypeNone       PublicreportNuisancepreferreddaterangetype = "none"
+	PublicreportNuisancepreferreddaterangetypeAnyTime    PublicreportNuisancepreferreddaterangetype = "any-time"
+	PublicreportNuisancepreferreddaterangetypeInTwoWeeks PublicreportNuisancepreferreddaterangetype = "in-two-weeks"
+	PublicreportNuisancepreferreddaterangetypeNextWeek   PublicreportNuisancepreferreddaterangetype = "next-week"
+)
+
+func AllPublicreportNuisancepreferreddaterangetype() []PublicreportNuisancepreferreddaterangetype {
+	return []PublicreportNuisancepreferreddaterangetype{
+		PublicreportNuisancepreferreddaterangetypeNone,
+		PublicreportNuisancepreferreddaterangetypeAnyTime,
+		PublicreportNuisancepreferreddaterangetypeInTwoWeeks,
+		PublicreportNuisancepreferreddaterangetypeNextWeek,
+	}
+}
+
+type PublicreportNuisancepreferreddaterangetype string
+
+func (e PublicreportNuisancepreferreddaterangetype) String() string {
+	return string(e)
+}
+
+func (e PublicreportNuisancepreferreddaterangetype) Valid() bool {
+	switch e {
+	case PublicreportNuisancepreferreddaterangetypeNone,
+		PublicreportNuisancepreferreddaterangetypeAnyTime,
+		PublicreportNuisancepreferreddaterangetypeInTwoWeeks,
+		PublicreportNuisancepreferreddaterangetypeNextWeek:
+		return true
+	default:
+		return false
+	}
+}
+
+// useful when testing in other packages
+func (e PublicreportNuisancepreferreddaterangetype) All() []PublicreportNuisancepreferreddaterangetype {
+	return AllPublicreportNuisancepreferreddaterangetype()
+}
+
+func (e PublicreportNuisancepreferreddaterangetype) MarshalText() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancepreferreddaterangetype) UnmarshalText(text []byte) error {
+	return e.Scan(text)
+}
+
+func (e PublicreportNuisancepreferreddaterangetype) MarshalBinary() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancepreferreddaterangetype) UnmarshalBinary(data []byte) error {
+	return e.Scan(data)
+}
+
+func (e PublicreportNuisancepreferreddaterangetype) Value() (driver.Value, error) {
+	return string(e), nil
+}
+
+func (e *PublicreportNuisancepreferreddaterangetype) Scan(value any) error {
+	switch x := value.(type) {
+	case string:
+		*e = PublicreportNuisancepreferreddaterangetype(x)
+	case []byte:
+		*e = PublicreportNuisancepreferreddaterangetype(x)
+	case nil:
+		return fmt.Errorf("cannot nil into PublicreportNuisancepreferreddaterangetype")
+	default:
+		return fmt.Errorf("cannot scan type %T: %v", value, value)
+	}
+
+	if !e.Valid() {
+		return fmt.Errorf("invalid PublicreportNuisancepreferreddaterangetype value: %s", *e)
+	}
+
+	return nil
+}
+
+// Enum values for PublicreportNuisancepreferredtimetype
+const (
+	PublicreportNuisancepreferredtimetypeNone      PublicreportNuisancepreferredtimetype = "none"
+	PublicreportNuisancepreferredtimetypeAfternoon PublicreportNuisancepreferredtimetype = "afternoon"
+	PublicreportNuisancepreferredtimetypeAnyTime   PublicreportNuisancepreferredtimetype = "any-time"
+	PublicreportNuisancepreferredtimetypeMorning   PublicreportNuisancepreferredtimetype = "morning"
+)
+
+func AllPublicreportNuisancepreferredtimetype() []PublicreportNuisancepreferredtimetype {
+	return []PublicreportNuisancepreferredtimetype{
+		PublicreportNuisancepreferredtimetypeNone,
+		PublicreportNuisancepreferredtimetypeAfternoon,
+		PublicreportNuisancepreferredtimetypeAnyTime,
+		PublicreportNuisancepreferredtimetypeMorning,
+	}
+}
+
+type PublicreportNuisancepreferredtimetype string
+
+func (e PublicreportNuisancepreferredtimetype) String() string {
+	return string(e)
+}
+
+func (e PublicreportNuisancepreferredtimetype) Valid() bool {
+	switch e {
+	case PublicreportNuisancepreferredtimetypeNone,
+		PublicreportNuisancepreferredtimetypeAfternoon,
+		PublicreportNuisancepreferredtimetypeAnyTime,
+		PublicreportNuisancepreferredtimetypeMorning:
+		return true
+	default:
+		return false
+	}
+}
+
+// useful when testing in other packages
+func (e PublicreportNuisancepreferredtimetype) All() []PublicreportNuisancepreferredtimetype {
+	return AllPublicreportNuisancepreferredtimetype()
+}
+
+func (e PublicreportNuisancepreferredtimetype) MarshalText() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancepreferredtimetype) UnmarshalText(text []byte) error {
+	return e.Scan(text)
+}
+
+func (e PublicreportNuisancepreferredtimetype) MarshalBinary() ([]byte, error) {
+	return []byte(e), nil
+}
+
+func (e *PublicreportNuisancepreferredtimetype) UnmarshalBinary(data []byte) error {
+	return e.Scan(data)
+}
+
+func (e PublicreportNuisancepreferredtimetype) Value() (driver.Value, error) {
+	return string(e), nil
+}
+
+func (e *PublicreportNuisancepreferredtimetype) Scan(value any) error {
+	switch x := value.(type) {
+	case string:
+		*e = PublicreportNuisancepreferredtimetype(x)
+	case []byte:
+		*e = PublicreportNuisancepreferredtimetype(x)
+	case nil:
+		return fmt.Errorf("cannot nil into PublicreportNuisancepreferredtimetype")
+	default:
+		return fmt.Errorf("cannot scan type %T: %v", value, value)
+	}
+
+	if !e.Valid() {
+		return fmt.Errorf("invalid PublicreportNuisancepreferredtimetype value: %s", *e)
+	}
+
+	return nil
+}
--- a/db/factory/bobfactory_context.bob.go
+++ b/db/factory/bobfactory_context.bob.go
@ -208,6 +208,9 @@ var (
 	organizationRelNoteImagesCtx              = newContextual[bool]("note_image.organization.note_image.note_image_organization_id_fkey")
 	organizationRelUserCtx                    = newContextual[bool]("organization.user_.user_.user__organization_id_fkey")

+	// Relationship Contexts for publicreport.nuisance
+	publicreportNuisanceWithParentsCascadingCtx = newContextual[bool]("publicreportNuisanceWithParentsCascading")
+
 	// Relationship Contexts for publicreport.quick
 	publicreportQuickWithParentsCascadingCtx = newContextual[bool]("publicreportQuickWithParentsCascading")
 	publicreportQuickRelQuickPhotosCtx       = newContextual[bool]("publicreport.quick.publicreport.quick_photo.publicreport.quick_photo.quick_photo_quick_id_fkey")
--- a/db/factory/bobfactory_main.bob.go
+++ b/db/factory/bobfactory_main.bob.go
@ -58,6 +58,7 @@ type Factory struct {
 	baseNotificationMods                      NotificationModSlice
 	baseOauthTokenMods                        OauthTokenModSlice
 	baseOrganizationMods                      OrganizationModSlice
+	basePublicreportNuisanceMods              PublicreportNuisanceModSlice
 	basePublicreportQuickMods                 PublicreportQuickModSlice
 	basePublicreportQuickPhotoMods            PublicreportQuickPhotoModSlice
 	baseRasterColumnMods                      RasterColumnModSlice
@ -2372,6 +2373,53 @@ func (f *Factory) FromExistingOrganization(m *models.Organization) *Organization
 	return o
 }

+func (f *Factory) NewPublicreportNuisance(mods ...PublicreportNuisanceMod) *PublicreportNuisanceTemplate {
+	return f.NewPublicreportNuisanceWithContext(context.Background(), mods...)
+}
+
+func (f *Factory) NewPublicreportNuisanceWithContext(ctx context.Context, mods ...PublicreportNuisanceMod) *PublicreportNuisanceTemplate {
+	o := &PublicreportNuisanceTemplate{f: f}
+
+	if f != nil {
+		f.basePublicreportNuisanceMods.Apply(ctx, o)
+	}
+
+	PublicreportNuisanceModSlice(mods).Apply(ctx, o)
+
+	return o
+}
+
+func (f *Factory) FromExistingPublicreportNuisance(m *models.PublicreportNuisance) *PublicreportNuisanceTemplate {
+	o := &PublicreportNuisanceTemplate{f: f, alreadyPersisted: true}
+
+	o.ID = func() int32 { return m.ID }
+	o.AdditionalInfo = func() string { return m.AdditionalInfo }
+	o.Created = func() time.Time { return m.Created }
+	o.Duration = func() enums.PublicreportNuisancedurationtype { return m.Duration }
+	o.Email = func() string { return m.Email }
+	o.InspectionType = func() enums.PublicreportNuisanceinspectiontype { return m.InspectionType }
+	o.Location = func() enums.PublicreportNuisancelocationtype { return m.Location }
+	o.PreferredDateRange = func() enums.PublicreportNuisancepreferreddaterangetype { return m.PreferredDateRange }
+	o.PreferredTime = func() enums.PublicreportNuisancepreferredtimetype { return m.PreferredTime }
+	o.RequestCall = func() bool { return m.RequestCall }
+	o.Severity = func() int16 { return m.Severity }
+	o.SourceContainer = func() bool { return m.SourceContainer }
+	o.SourceDescription = func() string { return m.SourceDescription }
+	o.SourceRoof = func() bool { return m.SourceRoof }
+	o.SourceStagnant = func() bool { return m.SourceStagnant }
+	o.TimeOfDayDay = func() bool { return m.TimeOfDayDay }
+	o.TimeOfDayEarly = func() bool { return m.TimeOfDayEarly }
+	o.TimeOfDayEvening = func() bool { return m.TimeOfDayEvening }
+	o.TimeOfDayNight = func() bool { return m.TimeOfDayNight }
+	o.PublicID = func() string { return m.PublicID }
+	o.ReporterAddress = func() string { return m.ReporterAddress }
+	o.ReporterEmail = func() string { return m.ReporterEmail }
+	o.ReporterName = func() string { return m.ReporterName }
+	o.ReporterPhone = func() string { return m.ReporterPhone }
+
+	return o
+}
+
 func (f *Factory) NewPublicreportQuick(mods ...PublicreportQuickMod) *PublicreportQuickTemplate {
 	return f.NewPublicreportQuickWithContext(context.Background(), mods...)
 }
@ -2953,6 +3001,14 @@ func (f *Factory) AddBaseOrganizationMod(mods ...OrganizationMod) {
 	f.baseOrganizationMods = append(f.baseOrganizationMods, mods...)
 }

+func (f *Factory) ClearBasePublicreportNuisanceMods() {
+	f.basePublicreportNuisanceMods = nil
+}
+
+func (f *Factory) AddBasePublicreportNuisanceMod(mods ...PublicreportNuisanceMod) {
+	f.basePublicreportNuisanceMods = append(f.basePublicreportNuisanceMods, mods...)
+}
+
 func (f *Factory) ClearBasePublicreportQuickMods() {
 	f.basePublicreportQuickMods = nil
 }
--- a/db/factory/bobfactory_random.bob.go
+++ b/db/factory/bobfactory_random.bob.go
@ -87,6 +87,56 @@ func random_enums_Notificationtype(f *faker.Faker, limits ...string) enums.Notif
 	return all[f.IntBetween(0, len(all)-1)]
 }

+func random_enums_PublicreportNuisancedurationtype(f *faker.Faker, limits ...string) enums.PublicreportNuisancedurationtype {
+	if f == nil {
+		f = &defaultFaker
+	}
+
+	var e enums.PublicreportNuisancedurationtype
+	all := e.All()
+	return all[f.IntBetween(0, len(all)-1)]
+}
+
+func random_enums_PublicreportNuisanceinspectiontype(f *faker.Faker, limits ...string) enums.PublicreportNuisanceinspectiontype {
+	if f == nil {
+		f = &defaultFaker
+	}
+
+	var e enums.PublicreportNuisanceinspectiontype
+	all := e.All()
+	return all[f.IntBetween(0, len(all)-1)]
+}
+
+func random_enums_PublicreportNuisancelocationtype(f *faker.Faker, limits ...string) enums.PublicreportNuisancelocationtype {
+	if f == nil {
+		f = &defaultFaker
+	}
+
+	var e enums.PublicreportNuisancelocationtype
+	all := e.All()
+	return all[f.IntBetween(0, len(all)-1)]
+}
+
+func random_enums_PublicreportNuisancepreferreddaterangetype(f *faker.Faker, limits ...string) enums.PublicreportNuisancepreferreddaterangetype {
+	if f == nil {
+		f = &defaultFaker
+	}
+
+	var e enums.PublicreportNuisancepreferreddaterangetype
+	all := e.All()
+	return all[f.IntBetween(0, len(all)-1)]
+}
+
+func random_enums_PublicreportNuisancepreferredtimetype(f *faker.Faker, limits ...string) enums.PublicreportNuisancepreferredtimetype {
+	if f == nil {
+		f = &defaultFaker
+	}
+
+	var e enums.PublicreportNuisancepreferredtimetype
+	all := e.All()
+	return all[f.IntBetween(0, len(all)-1)]
+}
+
 func random_float32(f *faker.Faker, limits ...string) float32 {
 	if f == nil {
 		f = &defaultFaker
--- a/db/factory/publicreport.nuisance.bob.go
+++ b/db/factory/publicreport.nuisance.bob.go
--- a/db/migrations/00025_public_nuisance.sql
+++ b/db/migrations/00025_public_nuisance.sql
@ -0,0 +1,71 @@
+-- +goose Up
+CREATE TYPE publicreport.NuisanceDurationType AS ENUM (
+	'none',
+	'just-noticed',
+	'few-days',
+	'1-2-weeks',
+	'2-4-weeks',
+	'1-3-months',
+	'seasonal'
+);
+CREATE TYPE publicreport.NuisanceLocationType AS ENUM (
+	'none',
+	'front-yard',
+	'backyard',
+	'patio',
+	'garden',
+	'pool-area',
+	'throughout',
+	'indoors',
+	'other'
+);
+CREATE TYPE publicreport.NuisanceInspectionType AS ENUM (
+	'neighborhood',
+	'property'
+);
+CREATE TYPE publicreport.NuisancePreferredDateRangeType AS ENUM (
+	'none',
+	'any-time',
+	'in-two-weeks',
+	'next-week'
+);
+CREATE TYPE publicreport.NuisancePreferredTimeType AS ENUM (
+	'none',
+	'afternoon',
+	'any-time',
+	'morning'
+);
+CREATE TABLE publicreport.nuisance (
+	id SERIAL PRIMARY KEY,
+	additional_info TEXT NOT NULL,
+	created TIMESTAMP WITHOUT TIME ZONE NOT NULL,
+	duration publicreport.NuisanceDurationType NOT NULL,
+	email TEXT NOT NULL,
+	inspection_type publicreport.NuisanceInspectionType NOT NULL,
+	location publicreport.NuisanceLocationType NOT NULL,
+	preferred_date_range publicreport.NuisancePreferredDateRangeType NOT NULL,
+	preferred_time publicreport.NuisancePreferredTimeType NOT NULL,
+	request_call BOOLEAN NOT NULL,
+	severity SMALLINT NOT NULL,
+	source_container BOOLEAN NOT NULL,
+	source_description TEXT NOT NULL,
+	source_roof BOOLEAN NOT NULL,
+	source_stagnant BOOLEAN NOT NULL,
+	time_of_day_day BOOLEAN NOT NULL,
+	time_of_day_early BOOLEAN NOT NULL,
+	time_of_day_evening BOOLEAN NOT NULL,
+	time_of_day_night BOOLEAN NOT NULL,
+	public_id TEXT NOT NULL UNIQUE,
+	reporter_address TEXT NOT NULL,
+	reporter_email TEXT NOT NULL,
+	reporter_name TEXT NOT NULL,
+	reporter_phone TEXT NOT NULL
+);
+
+-- +goose Down
+DROP TABLE publicreport.nuisance;
+DROP TYPE publicreport.NuisanceDurationType;
+DROP TYPE publicreport.NuisanceLocationType;
+DROP TYPE publicreport.NuisanceInspectionType;
+DROP TYPE publicreport.NuisancePreferredDateRangeType;
+DROP TYPE publicreport.NuisancePreferredTimeType;
--- a/db/models/bob_where.bob.go
+++ b/db/models/bob_where.bob.go
@ -58,6 +58,7 @@ func Where[Q psql.Filterable]() struct {
 	Notifications                      notificationWhere[Q]
 	OauthTokens                        oauthTokenWhere[Q]
 	Organizations                      organizationWhere[Q]
+	PublicreportNuisances              publicreportNuisanceWhere[Q]
 	PublicreportQuicks                 publicreportQuickWhere[Q]
 	PublicreportQuickPhotos            publicreportQuickPhotoWhere[Q]
 	RasterColumns                      rasterColumnWhere[Q]
@ -108,6 +109,7 @@ func Where[Q psql.Filterable]() struct {
 		Notifications                      notificationWhere[Q]
 		OauthTokens                        oauthTokenWhere[Q]
 		Organizations                      organizationWhere[Q]
+		PublicreportNuisances              publicreportNuisanceWhere[Q]
 		PublicreportQuicks                 publicreportQuickWhere[Q]
 		PublicreportQuickPhotos            publicreportQuickPhotoWhere[Q]
 		RasterColumns                      rasterColumnWhere[Q]
@ -157,6 +159,7 @@ func Where[Q psql.Filterable]() struct {
 		Notifications:                      buildNotificationWhere[Q](Notifications.Columns),
 		OauthTokens:                        buildOauthTokenWhere[Q](OauthTokens.Columns),
 		Organizations:                      buildOrganizationWhere[Q](Organizations.Columns),
+		PublicreportNuisances:              buildPublicreportNuisanceWhere[Q](PublicreportNuisances.Columns),
 		PublicreportQuicks:                 buildPublicreportQuickWhere[Q](PublicreportQuicks.Columns),
 		PublicreportQuickPhotos:            buildPublicreportQuickPhotoWhere[Q](PublicreportQuickPhotos.Columns),
 		RasterColumns:                      buildRasterColumnWhere[Q](RasterColumns.Columns),
--- a/db/models/publicreport.nuisance.bob.go
+++ b/db/models/publicreport.nuisance.bob.go
@ -0,0 +1,925 @@
+// Code generated by BobGen psql v0.0.4-0.20260105020634-53e08d840e47+dirty. DO NOT EDIT.
+// This file is meant to be re-generated in place and/or deleted at any time.
+
+package models
+
+import (
+	"context"
+	"io"
+	"time"
+
+	enums "github.com/Gleipnir-Technology/nidus-sync/db/enums"
+	"github.com/aarondl/opt/omit"
+	"github.com/stephenafamo/bob"
+	"github.com/stephenafamo/bob/dialect/psql"
+	"github.com/stephenafamo/bob/dialect/psql/dialect"
+	"github.com/stephenafamo/bob/dialect/psql/dm"
+	"github.com/stephenafamo/bob/dialect/psql/sm"
+	"github.com/stephenafamo/bob/dialect/psql/um"
+	"github.com/stephenafamo/bob/expr"
+)
+
+// PublicreportNuisance is an object representing the database table.
+type PublicreportNuisance struct {
+	ID                 int32                                            `db:"id,pk" `
+	AdditionalInfo     string                                           `db:"additional_info" `
+	Created            time.Time                                        `db:"created" `
+	Duration           enums.PublicreportNuisancedurationtype           `db:"duration" `
+	Email              string                                           `db:"email" `
+	InspectionType     enums.PublicreportNuisanceinspectiontype         `db:"inspection_type" `
+	Location           enums.PublicreportNuisancelocationtype           `db:"location" `
+	PreferredDateRange enums.PublicreportNuisancepreferreddaterangetype `db:"preferred_date_range" `
+	PreferredTime      enums.PublicreportNuisancepreferredtimetype      `db:"preferred_time" `
+	RequestCall        bool                                             `db:"request_call" `
+	Severity           int16                                            `db:"severity" `
+	SourceContainer    bool                                             `db:"source_container" `
+	SourceDescription  string                                           `db:"source_description" `
+	SourceRoof         bool                                             `db:"source_roof" `
+	SourceStagnant     bool                                             `db:"source_stagnant" `
+	TimeOfDayDay       bool                                             `db:"time_of_day_day" `
+	TimeOfDayEarly     bool                                             `db:"time_of_day_early" `
+	TimeOfDayEvening   bool                                             `db:"time_of_day_evening" `
+	TimeOfDayNight     bool                                             `db:"time_of_day_night" `
+	PublicID           string                                           `db:"public_id" `
+	ReporterAddress    string                                           `db:"reporter_address" `
+	ReporterEmail      string                                           `db:"reporter_email" `
+	ReporterName       string                                           `db:"reporter_name" `
+	ReporterPhone      string                                           `db:"reporter_phone" `
+}
+
+// PublicreportNuisanceSlice is an alias for a slice of pointers to PublicreportNuisance.
+// This should almost always be used instead of []*PublicreportNuisance.
+type PublicreportNuisanceSlice []*PublicreportNuisance
+
+// PublicreportNuisances contains methods to work with the nuisance table
+var PublicreportNuisances = psql.NewTablex[*PublicreportNuisance, PublicreportNuisanceSlice, *PublicreportNuisanceSetter]("publicreport", "nuisance", buildPublicreportNuisanceColumns("publicreport.nuisance"))
+
+// PublicreportNuisancesQuery is a query on the nuisance table
+type PublicreportNuisancesQuery = *psql.ViewQuery[*PublicreportNuisance, PublicreportNuisanceSlice]
+
+func buildPublicreportNuisanceColumns(alias string) publicreportNuisanceColumns {
+	return publicreportNuisanceColumns{
+		ColumnsExpr: expr.NewColumnsExpr(
+			"id", "additional_info", "created", "duration", "email", "inspection_type", "location", "preferred_date_range", "preferred_time", "request_call", "severity", "source_container", "source_description", "source_roof", "source_stagnant", "time_of_day_day", "time_of_day_early", "time_of_day_evening", "time_of_day_night", "public_id", "reporter_address", "reporter_email", "reporter_name", "reporter_phone",
+		).WithParent("publicreport.nuisance"),
+		tableAlias:         alias,
+		ID:                 psql.Quote(alias, "id"),
+		AdditionalInfo:     psql.Quote(alias, "additional_info"),
+		Created:            psql.Quote(alias, "created"),
+		Duration:           psql.Quote(alias, "duration"),
+		Email:              psql.Quote(alias, "email"),
+		InspectionType:     psql.Quote(alias, "inspection_type"),
+		Location:           psql.Quote(alias, "location"),
+		PreferredDateRange: psql.Quote(alias, "preferred_date_range"),
+		PreferredTime:      psql.Quote(alias, "preferred_time"),
+		RequestCall:        psql.Quote(alias, "request_call"),
+		Severity:           psql.Quote(alias, "severity"),
+		SourceContainer:    psql.Quote(alias, "source_container"),
+		SourceDescription:  psql.Quote(alias, "source_description"),
+		SourceRoof:         psql.Quote(alias, "source_roof"),
+		SourceStagnant:     psql.Quote(alias, "source_stagnant"),
+		TimeOfDayDay:       psql.Quote(alias, "time_of_day_day"),
+		TimeOfDayEarly:     psql.Quote(alias, "time_of_day_early"),
+		TimeOfDayEvening:   psql.Quote(alias, "time_of_day_evening"),
+		TimeOfDayNight:     psql.Quote(alias, "time_of_day_night"),
+		PublicID:           psql.Quote(alias, "public_id"),
+		ReporterAddress:    psql.Quote(alias, "reporter_address"),
+		ReporterEmail:      psql.Quote(alias, "reporter_email"),
+		ReporterName:       psql.Quote(alias, "reporter_name"),
+		ReporterPhone:      psql.Quote(alias, "reporter_phone"),
+	}
+}
+
+type publicreportNuisanceColumns struct {
+	expr.ColumnsExpr
+	tableAlias         string
+	ID                 psql.Expression
+	AdditionalInfo     psql.Expression
+	Created            psql.Expression
+	Duration           psql.Expression
+	Email              psql.Expression
+	InspectionType     psql.Expression
+	Location           psql.Expression
+	PreferredDateRange psql.Expression
+	PreferredTime      psql.Expression
+	RequestCall        psql.Expression
+	Severity           psql.Expression
+	SourceContainer    psql.Expression
+	SourceDescription  psql.Expression
+	SourceRoof         psql.Expression
+	SourceStagnant     psql.Expression
+	TimeOfDayDay       psql.Expression
+	TimeOfDayEarly     psql.Expression
+	TimeOfDayEvening   psql.Expression
+	TimeOfDayNight     psql.Expression
+	PublicID           psql.Expression
+	ReporterAddress    psql.Expression
+	ReporterEmail      psql.Expression
+	ReporterName       psql.Expression
+	ReporterPhone      psql.Expression
+}
+
+func (c publicreportNuisanceColumns) Alias() string {
+	return c.tableAlias
+}
+
+func (publicreportNuisanceColumns) AliasedAs(alias string) publicreportNuisanceColumns {
+	return buildPublicreportNuisanceColumns(alias)
+}
+
+// PublicreportNuisanceSetter is used for insert/upsert/update operations
+// All values are optional, and do not have to be set
+// Generated columns are not included
+type PublicreportNuisanceSetter struct {
+	ID                 omit.Val[int32]                                            `db:"id,pk" `
+	AdditionalInfo     omit.Val[string]                                           `db:"additional_info" `
+	Created            omit.Val[time.Time]                                        `db:"created" `
+	Duration           omit.Val[enums.PublicreportNuisancedurationtype]           `db:"duration" `
+	Email              omit.Val[string]                                           `db:"email" `
+	InspectionType     omit.Val[enums.PublicreportNuisanceinspectiontype]         `db:"inspection_type" `
+	Location           omit.Val[enums.PublicreportNuisancelocationtype]           `db:"location" `
+	PreferredDateRange omit.Val[enums.PublicreportNuisancepreferreddaterangetype] `db:"preferred_date_range" `
+	PreferredTime      omit.Val[enums.PublicreportNuisancepreferredtimetype]      `db:"preferred_time" `
+	RequestCall        omit.Val[bool]                                             `db:"request_call" `
+	Severity           omit.Val[int16]                                            `db:"severity" `
+	SourceContainer    omit.Val[bool]                                             `db:"source_container" `
+	SourceDescription  omit.Val[string]                                           `db:"source_description" `
+	SourceRoof         omit.Val[bool]                                             `db:"source_roof" `
+	SourceStagnant     omit.Val[bool]                                             `db:"source_stagnant" `
+	TimeOfDayDay       omit.Val[bool]                                             `db:"time_of_day_day" `
+	TimeOfDayEarly     omit.Val[bool]                                             `db:"time_of_day_early" `
+	TimeOfDayEvening   omit.Val[bool]                                             `db:"time_of_day_evening" `
+	TimeOfDayNight     omit.Val[bool]                                             `db:"time_of_day_night" `
+	PublicID           omit.Val[string]                                           `db:"public_id" `
+	ReporterAddress    omit.Val[string]                                           `db:"reporter_address" `
+	ReporterEmail      omit.Val[string]                                           `db:"reporter_email" `
+	ReporterName       omit.Val[string]                                           `db:"reporter_name" `
+	ReporterPhone      omit.Val[string]                                           `db:"reporter_phone" `
+}
+
+func (s PublicreportNuisanceSetter) SetColumns() []string {
+	vals := make([]string, 0, 24)
+	if s.ID.IsValue() {
+		vals = append(vals, "id")
+	}
+	if s.AdditionalInfo.IsValue() {
+		vals = append(vals, "additional_info")
+	}
+	if s.Created.IsValue() {
+		vals = append(vals, "created")
+	}
+	if s.Duration.IsValue() {
+		vals = append(vals, "duration")
+	}
+	if s.Email.IsValue() {
+		vals = append(vals, "email")
+	}
+	if s.InspectionType.IsValue() {
+		vals = append(vals, "inspection_type")
+	}
+	if s.Location.IsValue() {
+		vals = append(vals, "location")
+	}
+	if s.PreferredDateRange.IsValue() {
+		vals = append(vals, "preferred_date_range")
+	}
+	if s.PreferredTime.IsValue() {
+		vals = append(vals, "preferred_time")
+	}
+	if s.RequestCall.IsValue() {
+		vals = append(vals, "request_call")
+	}
+	if s.Severity.IsValue() {
+		vals = append(vals, "severity")
+	}
+	if s.SourceContainer.IsValue() {
+		vals = append(vals, "source_container")
+	}
+	if s.SourceDescription.IsValue() {
+		vals = append(vals, "source_description")
+	}
+	if s.SourceRoof.IsValue() {
+		vals = append(vals, "source_roof")
+	}
+	if s.SourceStagnant.IsValue() {
+		vals = append(vals, "source_stagnant")
+	}
+	if s.TimeOfDayDay.IsValue() {
+		vals = append(vals, "time_of_day_day")
+	}
+	if s.TimeOfDayEarly.IsValue() {
+		vals = append(vals, "time_of_day_early")
+	}
+	if s.TimeOfDayEvening.IsValue() {
+		vals = append(vals, "time_of_day_evening")
+	}
+	if s.TimeOfDayNight.IsValue() {
+		vals = append(vals, "time_of_day_night")
+	}
+	if s.PublicID.IsValue() {
+		vals = append(vals, "public_id")
+	}
+	if s.ReporterAddress.IsValue() {
+		vals = append(vals, "reporter_address")
+	}
+	if s.ReporterEmail.IsValue() {
+		vals = append(vals, "reporter_email")
+	}
+	if s.ReporterName.IsValue() {
+		vals = append(vals, "reporter_name")
+	}
+	if s.ReporterPhone.IsValue() {
+		vals = append(vals, "reporter_phone")
+	}
+	return vals
+}
+
+func (s PublicreportNuisanceSetter) Overwrite(t *PublicreportNuisance) {
+	if s.ID.IsValue() {
+		t.ID = s.ID.MustGet()
+	}
+	if s.AdditionalInfo.IsValue() {
+		t.AdditionalInfo = s.AdditionalInfo.MustGet()
+	}
+	if s.Created.IsValue() {
+		t.Created = s.Created.MustGet()
+	}
+	if s.Duration.IsValue() {
+		t.Duration = s.Duration.MustGet()
+	}
+	if s.Email.IsValue() {
+		t.Email = s.Email.MustGet()
+	}
+	if s.InspectionType.IsValue() {
+		t.InspectionType = s.InspectionType.MustGet()
+	}
+	if s.Location.IsValue() {
+		t.Location = s.Location.MustGet()
+	}
+	if s.PreferredDateRange.IsValue() {
+		t.PreferredDateRange = s.PreferredDateRange.MustGet()
+	}
+	if s.PreferredTime.IsValue() {
+		t.PreferredTime = s.PreferredTime.MustGet()
+	}
+	if s.RequestCall.IsValue() {
+		t.RequestCall = s.RequestCall.MustGet()
+	}
+	if s.Severity.IsValue() {
+		t.Severity = s.Severity.MustGet()
+	}
+	if s.SourceContainer.IsValue() {
+		t.SourceContainer = s.SourceContainer.MustGet()
+	}
+	if s.SourceDescription.IsValue() {
+		t.SourceDescription = s.SourceDescription.MustGet()
+	}
+	if s.SourceRoof.IsValue() {
+		t.SourceRoof = s.SourceRoof.MustGet()
+	}
+	if s.SourceStagnant.IsValue() {
+		t.SourceStagnant = s.SourceStagnant.MustGet()
+	}
+	if s.TimeOfDayDay.IsValue() {
+		t.TimeOfDayDay = s.TimeOfDayDay.MustGet()
+	}
+	if s.TimeOfDayEarly.IsValue() {
+		t.TimeOfDayEarly = s.TimeOfDayEarly.MustGet()
+	}
+	if s.TimeOfDayEvening.IsValue() {
+		t.TimeOfDayEvening = s.TimeOfDayEvening.MustGet()
+	}
+	if s.TimeOfDayNight.IsValue() {
+		t.TimeOfDayNight = s.TimeOfDayNight.MustGet()
+	}
+	if s.PublicID.IsValue() {
+		t.PublicID = s.PublicID.MustGet()
+	}
+	if s.ReporterAddress.IsValue() {
+		t.ReporterAddress = s.ReporterAddress.MustGet()
+	}
+	if s.ReporterEmail.IsValue() {
+		t.ReporterEmail = s.ReporterEmail.MustGet()
+	}
+	if s.ReporterName.IsValue() {
+		t.ReporterName = s.ReporterName.MustGet()
+	}
+	if s.ReporterPhone.IsValue() {
+		t.ReporterPhone = s.ReporterPhone.MustGet()
+	}
+}
+
+func (s *PublicreportNuisanceSetter) Apply(q *dialect.InsertQuery) {
+	q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
+		return PublicreportNuisances.BeforeInsertHooks.RunHooks(ctx, exec, s)
+	})
+
+	q.AppendValues(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+		vals := make([]bob.Expression, 24)
+		if s.ID.IsValue() {
+			vals[0] = psql.Arg(s.ID.MustGet())
+		} else {
+			vals[0] = psql.Raw("DEFAULT")
+		}
+
+		if s.AdditionalInfo.IsValue() {
+			vals[1] = psql.Arg(s.AdditionalInfo.MustGet())
+		} else {
+			vals[1] = psql.Raw("DEFAULT")
+		}
+
+		if s.Created.IsValue() {
+			vals[2] = psql.Arg(s.Created.MustGet())
+		} else {
+			vals[2] = psql.Raw("DEFAULT")
+		}
+
+		if s.Duration.IsValue() {
+			vals[3] = psql.Arg(s.Duration.MustGet())
+		} else {
+			vals[3] = psql.Raw("DEFAULT")
+		}
+
+		if s.Email.IsValue() {
+			vals[4] = psql.Arg(s.Email.MustGet())
+		} else {
+			vals[4] = psql.Raw("DEFAULT")
+		}
+
+		if s.InspectionType.IsValue() {
+			vals[5] = psql.Arg(s.InspectionType.MustGet())
+		} else {
+			vals[5] = psql.Raw("DEFAULT")
+		}
+
+		if s.Location.IsValue() {
+			vals[6] = psql.Arg(s.Location.MustGet())
+		} else {
+			vals[6] = psql.Raw("DEFAULT")
+		}
+
+		if s.PreferredDateRange.IsValue() {
+			vals[7] = psql.Arg(s.PreferredDateRange.MustGet())
+		} else {
+			vals[7] = psql.Raw("DEFAULT")
+		}
+
+		if s.PreferredTime.IsValue() {
+			vals[8] = psql.Arg(s.PreferredTime.MustGet())
+		} else {
+			vals[8] = psql.Raw("DEFAULT")
+		}
+
+		if s.RequestCall.IsValue() {
+			vals[9] = psql.Arg(s.RequestCall.MustGet())
+		} else {
+			vals[9] = psql.Raw("DEFAULT")
+		}
+
+		if s.Severity.IsValue() {
+			vals[10] = psql.Arg(s.Severity.MustGet())
+		} else {
+			vals[10] = psql.Raw("DEFAULT")
+		}
+
+		if s.SourceContainer.IsValue() {
+			vals[11] = psql.Arg(s.SourceContainer.MustGet())
+		} else {
+			vals[11] = psql.Raw("DEFAULT")
+		}
+
+		if s.SourceDescription.IsValue() {
+			vals[12] = psql.Arg(s.SourceDescription.MustGet())
+		} else {
+			vals[12] = psql.Raw("DEFAULT")
+		}
+
+		if s.SourceRoof.IsValue() {
+			vals[13] = psql.Arg(s.SourceRoof.MustGet())
+		} else {
+			vals[13] = psql.Raw("DEFAULT")
+		}
+
+		if s.SourceStagnant.IsValue() {
+			vals[14] = psql.Arg(s.SourceStagnant.MustGet())
+		} else {
+			vals[14] = psql.Raw("DEFAULT")
+		}
+
+		if s.TimeOfDayDay.IsValue() {
+			vals[15] = psql.Arg(s.TimeOfDayDay.MustGet())
+		} else {
+			vals[15] = psql.Raw("DEFAULT")
+		}
+
+		if s.TimeOfDayEarly.IsValue() {
+			vals[16] = psql.Arg(s.TimeOfDayEarly.MustGet())
+		} else {
+			vals[16] = psql.Raw("DEFAULT")
+		}
+
+		if s.TimeOfDayEvening.IsValue() {
+			vals[17] = psql.Arg(s.TimeOfDayEvening.MustGet())
+		} else {
+			vals[17] = psql.Raw("DEFAULT")
+		}
+
+		if s.TimeOfDayNight.IsValue() {
+			vals[18] = psql.Arg(s.TimeOfDayNight.MustGet())
+		} else {
+			vals[18] = psql.Raw("DEFAULT")
+		}
+
+		if s.PublicID.IsValue() {
+			vals[19] = psql.Arg(s.PublicID.MustGet())
+		} else {
+			vals[19] = psql.Raw("DEFAULT")
+		}
+
+		if s.ReporterAddress.IsValue() {
+			vals[20] = psql.Arg(s.ReporterAddress.MustGet())
+		} else {
+			vals[20] = psql.Raw("DEFAULT")
+		}
+
+		if s.ReporterEmail.IsValue() {
+			vals[21] = psql.Arg(s.ReporterEmail.MustGet())
+		} else {
+			vals[21] = psql.Raw("DEFAULT")
+		}
+
+		if s.ReporterName.IsValue() {
+			vals[22] = psql.Arg(s.ReporterName.MustGet())
+		} else {
+			vals[22] = psql.Raw("DEFAULT")
+		}
+
+		if s.ReporterPhone.IsValue() {
+			vals[23] = psql.Arg(s.ReporterPhone.MustGet())
+		} else {
+			vals[23] = psql.Raw("DEFAULT")
+		}
+
+		return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "")
+	}))
+}
+
+func (s PublicreportNuisanceSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
+	return um.Set(s.Expressions()...)
+}
+
+func (s PublicreportNuisanceSetter) Expressions(prefix ...string) []bob.Expression {
+	exprs := make([]bob.Expression, 0, 24)
+
+	if s.ID.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "id")...),
+			psql.Arg(s.ID),
+		}})
+	}
+
+	if s.AdditionalInfo.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "additional_info")...),
+			psql.Arg(s.AdditionalInfo),
+		}})
+	}
+
+	if s.Created.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "created")...),
+			psql.Arg(s.Created),
+		}})
+	}
+
+	if s.Duration.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "duration")...),
+			psql.Arg(s.Duration),
+		}})
+	}
+
+	if s.Email.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "email")...),
+			psql.Arg(s.Email),
+		}})
+	}
+
+	if s.InspectionType.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "inspection_type")...),
+			psql.Arg(s.InspectionType),
+		}})
+	}
+
+	if s.Location.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "location")...),
+			psql.Arg(s.Location),
+		}})
+	}
+
+	if s.PreferredDateRange.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "preferred_date_range")...),
+			psql.Arg(s.PreferredDateRange),
+		}})
+	}
+
+	if s.PreferredTime.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "preferred_time")...),
+			psql.Arg(s.PreferredTime),
+		}})
+	}
+
+	if s.RequestCall.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "request_call")...),
+			psql.Arg(s.RequestCall),
+		}})
+	}
+
+	if s.Severity.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "severity")...),
+			psql.Arg(s.Severity),
+		}})
+	}
+
+	if s.SourceContainer.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "source_container")...),
+			psql.Arg(s.SourceContainer),
+		}})
+	}
+
+	if s.SourceDescription.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "source_description")...),
+			psql.Arg(s.SourceDescription),
+		}})
+	}
+
+	if s.SourceRoof.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "source_roof")...),
+			psql.Arg(s.SourceRoof),
+		}})
+	}
+
+	if s.SourceStagnant.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "source_stagnant")...),
+			psql.Arg(s.SourceStagnant),
+		}})
+	}
+
+	if s.TimeOfDayDay.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "time_of_day_day")...),
+			psql.Arg(s.TimeOfDayDay),
+		}})
+	}
+
+	if s.TimeOfDayEarly.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "time_of_day_early")...),
+			psql.Arg(s.TimeOfDayEarly),
+		}})
+	}
+
+	if s.TimeOfDayEvening.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "time_of_day_evening")...),
+			psql.Arg(s.TimeOfDayEvening),
+		}})
+	}
+
+	if s.TimeOfDayNight.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "time_of_day_night")...),
+			psql.Arg(s.TimeOfDayNight),
+		}})
+	}
+
+	if s.PublicID.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "public_id")...),
+			psql.Arg(s.PublicID),
+		}})
+	}
+
+	if s.ReporterAddress.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "reporter_address")...),
+			psql.Arg(s.ReporterAddress),
+		}})
+	}
+
+	if s.ReporterEmail.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "reporter_email")...),
+			psql.Arg(s.ReporterEmail),
+		}})
+	}
+
+	if s.ReporterName.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "reporter_name")...),
+			psql.Arg(s.ReporterName),
+		}})
+	}
+
+	if s.ReporterPhone.IsValue() {
+		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
+			psql.Quote(append(prefix, "reporter_phone")...),
+			psql.Arg(s.ReporterPhone),
+		}})
+	}
+
+	return exprs
+}
+
+// FindPublicreportNuisance retrieves a single record by primary key
+// If cols is empty Find will return all columns.
+func FindPublicreportNuisance(ctx context.Context, exec bob.Executor, IDPK int32, cols ...string) (*PublicreportNuisance, error) {
+	if len(cols) == 0 {
+		return PublicreportNuisances.Query(
+			sm.Where(PublicreportNuisances.Columns.ID.EQ(psql.Arg(IDPK))),
+		).One(ctx, exec)
+	}
+
+	return PublicreportNuisances.Query(
+		sm.Where(PublicreportNuisances.Columns.ID.EQ(psql.Arg(IDPK))),
+		sm.Columns(PublicreportNuisances.Columns.Only(cols...)),
+	).One(ctx, exec)
+}
+
+// PublicreportNuisanceExists checks the presence of a single record by primary key
+func PublicreportNuisanceExists(ctx context.Context, exec bob.Executor, IDPK int32) (bool, error) {
+	return PublicreportNuisances.Query(
+		sm.Where(PublicreportNuisances.Columns.ID.EQ(psql.Arg(IDPK))),
+	).Exists(ctx, exec)
+}
+
+// AfterQueryHook is called after PublicreportNuisance is retrieved from the database
+func (o *PublicreportNuisance) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
+	var err error
+
+	switch queryType {
+	case bob.QueryTypeSelect:
+		ctx, err = PublicreportNuisances.AfterSelectHooks.RunHooks(ctx, exec, PublicreportNuisanceSlice{o})
+	case bob.QueryTypeInsert:
+		ctx, err = PublicreportNuisances.AfterInsertHooks.RunHooks(ctx, exec, PublicreportNuisanceSlice{o})
+	case bob.QueryTypeUpdate:
+		ctx, err = PublicreportNuisances.AfterUpdateHooks.RunHooks(ctx, exec, PublicreportNuisanceSlice{o})
+	case bob.QueryTypeDelete:
+		ctx, err = PublicreportNuisances.AfterDeleteHooks.RunHooks(ctx, exec, PublicreportNuisanceSlice{o})
+	}
+
+	return err
+}
+
+// primaryKeyVals returns the primary key values of the PublicreportNuisance
+func (o *PublicreportNuisance) primaryKeyVals() bob.Expression {
+	return psql.Arg(o.ID)
+}
+
+func (o *PublicreportNuisance) pkEQ() dialect.Expression {
+	return psql.Quote("publicreport.nuisance", "id").EQ(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+		return o.primaryKeyVals().WriteSQL(ctx, w, d, start)
+	}))
+}
+
+// Update uses an executor to update the PublicreportNuisance
+func (o *PublicreportNuisance) Update(ctx context.Context, exec bob.Executor, s *PublicreportNuisanceSetter) error {
+	v, err := PublicreportNuisances.Update(s.UpdateMod(), um.Where(o.pkEQ())).One(ctx, exec)
+	if err != nil {
+		return err
+	}
+
+	*o = *v
+
+	return nil
+}
+
+// Delete deletes a single PublicreportNuisance record with an executor
+func (o *PublicreportNuisance) Delete(ctx context.Context, exec bob.Executor) error {
+	_, err := PublicreportNuisances.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
+	return err
+}
+
+// Reload refreshes the PublicreportNuisance using the executor
+func (o *PublicreportNuisance) Reload(ctx context.Context, exec bob.Executor) error {
+	o2, err := PublicreportNuisances.Query(
+		sm.Where(PublicreportNuisances.Columns.ID.EQ(psql.Arg(o.ID))),
+	).One(ctx, exec)
+	if err != nil {
+		return err
+	}
+
+	*o = *o2
+
+	return nil
+}
+
+// AfterQueryHook is called after PublicreportNuisanceSlice is retrieved from the database
+func (o PublicreportNuisanceSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
+	var err error
+
+	switch queryType {
+	case bob.QueryTypeSelect:
+		ctx, err = PublicreportNuisances.AfterSelectHooks.RunHooks(ctx, exec, o)
+	case bob.QueryTypeInsert:
+		ctx, err = PublicreportNuisances.AfterInsertHooks.RunHooks(ctx, exec, o)
+	case bob.QueryTypeUpdate:
+		ctx, err = PublicreportNuisances.AfterUpdateHooks.RunHooks(ctx, exec, o)
+	case bob.QueryTypeDelete:
+		ctx, err = PublicreportNuisances.AfterDeleteHooks.RunHooks(ctx, exec, o)
+	}
+
+	return err
+}
+
+func (o PublicreportNuisanceSlice) pkIN() dialect.Expression {
+	if len(o) == 0 {
+		return psql.Raw("NULL")
+	}
+
+	return psql.Quote("publicreport.nuisance", "id").In(bob.ExpressionFunc(func(ctx context.Context, w io.StringWriter, d bob.Dialect, start int) ([]any, error) {
+		pkPairs := make([]bob.Expression, len(o))
+		for i, row := range o {
+			pkPairs[i] = row.primaryKeyVals()
+		}
+		return bob.ExpressSlice(ctx, w, d, start, pkPairs, "", ", ", "")
+	}))
+}
+
+// copyMatchingRows finds models in the given slice that have the same primary key
+// then it first copies the existing relationships from the old model to the new model
+// and then replaces the old model in the slice with the new model
+func (o PublicreportNuisanceSlice) copyMatchingRows(from ...*PublicreportNuisance) {
+	for i, old := range o {
+		for _, new := range from {
+			if new.ID != old.ID {
+				continue
+			}
+
+			o[i] = new
+			break
+		}
+	}
+}
+
+// UpdateMod modifies an update query with "WHERE primary_key IN (o...)"
+func (o PublicreportNuisanceSlice) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
+	return bob.ModFunc[*dialect.UpdateQuery](func(q *dialect.UpdateQuery) {
+		q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
+			return PublicreportNuisances.BeforeUpdateHooks.RunHooks(ctx, exec, o)
+		})
+
+		q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error {
+			var err error
+			switch retrieved := retrieved.(type) {
+			case *PublicreportNuisance:
+				o.copyMatchingRows(retrieved)
+			case []*PublicreportNuisance:
+				o.copyMatchingRows(retrieved...)
+			case PublicreportNuisanceSlice:
+				o.copyMatchingRows(retrieved...)
+			default:
+				// If the retrieved value is not a PublicreportNuisance or a slice of PublicreportNuisance
+				// then run the AfterUpdateHooks on the slice
+				_, err = PublicreportNuisances.AfterUpdateHooks.RunHooks(ctx, exec, o)
+			}
+
+			return err
+		}))
+
+		q.AppendWhere(o.pkIN())
+	})
+}
+
+// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)"
+func (o PublicreportNuisanceSlice) DeleteMod() bob.Mod[*dialect.DeleteQuery] {
+	return bob.ModFunc[*dialect.DeleteQuery](func(q *dialect.DeleteQuery) {
+		q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
+			return PublicreportNuisances.BeforeDeleteHooks.RunHooks(ctx, exec, o)
+		})
+
+		q.AppendLoader(bob.LoaderFunc(func(ctx context.Context, exec bob.Executor, retrieved any) error {
+			var err error
+			switch retrieved := retrieved.(type) {
+			case *PublicreportNuisance:
+				o.copyMatchingRows(retrieved)
+			case []*PublicreportNuisance:
+				o.copyMatchingRows(retrieved...)
+			case PublicreportNuisanceSlice:
+				o.copyMatchingRows(retrieved...)
+			default:
+				// If the retrieved value is not a PublicreportNuisance or a slice of PublicreportNuisance
+				// then run the AfterDeleteHooks on the slice
+				_, err = PublicreportNuisances.AfterDeleteHooks.RunHooks(ctx, exec, o)
+			}
+
+			return err
+		}))
+
+		q.AppendWhere(o.pkIN())
+	})
+}
+
+func (o PublicreportNuisanceSlice) UpdateAll(ctx context.Context, exec bob.Executor, vals PublicreportNuisanceSetter) error {
+	if len(o) == 0 {
+		return nil
+	}
+
+	_, err := PublicreportNuisances.Update(vals.UpdateMod(), o.UpdateMod()).All(ctx, exec)
+	return err
+}
+
+func (o PublicreportNuisanceSlice) DeleteAll(ctx context.Context, exec bob.Executor) error {
+	if len(o) == 0 {
+		return nil
+	}
+
+	_, err := PublicreportNuisances.Delete(o.DeleteMod()).Exec(ctx, exec)
+	return err
+}
+
+func (o PublicreportNuisanceSlice) ReloadAll(ctx context.Context, exec bob.Executor) error {
+	if len(o) == 0 {
+		return nil
+	}
+
+	o2, err := PublicreportNuisances.Query(sm.Where(o.pkIN())).All(ctx, exec)
+	if err != nil {
+		return err
+	}
+
+	o.copyMatchingRows(o2...)
+
+	return nil
+}
+
+type publicreportNuisanceWhere[Q psql.Filterable] struct {
+	ID                 psql.WhereMod[Q, int32]
+	AdditionalInfo     psql.WhereMod[Q, string]
+	Created            psql.WhereMod[Q, time.Time]
+	Duration           psql.WhereMod[Q, enums.PublicreportNuisancedurationtype]
+	Email              psql.WhereMod[Q, string]
+	InspectionType     psql.WhereMod[Q, enums.PublicreportNuisanceinspectiontype]
+	Location           psql.WhereMod[Q, enums.PublicreportNuisancelocationtype]
+	PreferredDateRange psql.WhereMod[Q, enums.PublicreportNuisancepreferreddaterangetype]
+	PreferredTime      psql.WhereMod[Q, enums.PublicreportNuisancepreferredtimetype]
+	RequestCall        psql.WhereMod[Q, bool]
+	Severity           psql.WhereMod[Q, int16]
+	SourceContainer    psql.WhereMod[Q, bool]
+	SourceDescription  psql.WhereMod[Q, string]
+	SourceRoof         psql.WhereMod[Q, bool]
+	SourceStagnant     psql.WhereMod[Q, bool]
+	TimeOfDayDay       psql.WhereMod[Q, bool]
+	TimeOfDayEarly     psql.WhereMod[Q, bool]
+	TimeOfDayEvening   psql.WhereMod[Q, bool]
+	TimeOfDayNight     psql.WhereMod[Q, bool]
+	PublicID           psql.WhereMod[Q, string]
+	ReporterAddress    psql.WhereMod[Q, string]
+	ReporterEmail      psql.WhereMod[Q, string]
+	ReporterName       psql.WhereMod[Q, string]
+	ReporterPhone      psql.WhereMod[Q, string]
+}
+
+func (publicreportNuisanceWhere[Q]) AliasedAs(alias string) publicreportNuisanceWhere[Q] {
+	return buildPublicreportNuisanceWhere[Q](buildPublicreportNuisanceColumns(alias))
+}
+
+func buildPublicreportNuisanceWhere[Q psql.Filterable](cols publicreportNuisanceColumns) publicreportNuisanceWhere[Q] {
+	return publicreportNuisanceWhere[Q]{
+		ID:                 psql.Where[Q, int32](cols.ID),
+		AdditionalInfo:     psql.Where[Q, string](cols.AdditionalInfo),
+		Created:            psql.Where[Q, time.Time](cols.Created),
+		Duration:           psql.Where[Q, enums.PublicreportNuisancedurationtype](cols.Duration),
+		Email:              psql.Where[Q, string](cols.Email),
+		InspectionType:     psql.Where[Q, enums.PublicreportNuisanceinspectiontype](cols.InspectionType),
+		Location:           psql.Where[Q, enums.PublicreportNuisancelocationtype](cols.Location),
+		PreferredDateRange: psql.Where[Q, enums.PublicreportNuisancepreferreddaterangetype](cols.PreferredDateRange),
+		PreferredTime:      psql.Where[Q, enums.PublicreportNuisancepreferredtimetype](cols.PreferredTime),
+		RequestCall:        psql.Where[Q, bool](cols.RequestCall),
+		Severity:           psql.Where[Q, int16](cols.Severity),
+		SourceContainer:    psql.Where[Q, bool](cols.SourceContainer),
+		SourceDescription:  psql.Where[Q, string](cols.SourceDescription),
+		SourceRoof:         psql.Where[Q, bool](cols.SourceRoof),
+		SourceStagnant:     psql.Where[Q, bool](cols.SourceStagnant),
+		TimeOfDayDay:       psql.Where[Q, bool](cols.TimeOfDayDay),
+		TimeOfDayEarly:     psql.Where[Q, bool](cols.TimeOfDayEarly),
+		TimeOfDayEvening:   psql.Where[Q, bool](cols.TimeOfDayEvening),
+		TimeOfDayNight:     psql.Where[Q, bool](cols.TimeOfDayNight),
+		PublicID:           psql.Where[Q, string](cols.PublicID),
+		ReporterAddress:    psql.Where[Q, string](cols.ReporterAddress),
+		ReporterEmail:      psql.Where[Q, string](cols.ReporterEmail),
+		ReporterName:       psql.Where[Q, string](cols.ReporterName),
+		ReporterPhone:      psql.Where[Q, string](cols.ReporterPhone),
+	}
+}