// Code generated by BobGen psql v0.42.5. DO NOT EDIT.
// This file is meant to be re-generated in place and/or deleted at any time.

package models

import (
	"context"
	"fmt"
	"io"
	"time"

	"github.com/Gleipnir-Technology/bob"
	"github.com/Gleipnir-Technology/bob/dialect/psql"
	"github.com/Gleipnir-Technology/bob/dialect/psql/dialect"
	"github.com/Gleipnir-Technology/bob/dialect/psql/dm"
	"github.com/Gleipnir-Technology/bob/dialect/psql/sm"
	"github.com/Gleipnir-Technology/bob/dialect/psql/um"
	"github.com/Gleipnir-Technology/bob/expr"
	"github.com/Gleipnir-Technology/bob/orm"
	"github.com/Gleipnir-Technology/bob/types/pgtypes"
	enums "github.com/Gleipnir-Technology/nidus-sync/db/enums"
	"github.com/aarondl/opt/null"
	"github.com/aarondl/opt/omit"
	"github.com/aarondl/opt/omitnull"
	"github.com/google/uuid"
	"github.com/stephenafamo/scan"
)

// PublicreportReport is an object representing the database table.
type PublicreportReport struct {
	AddressRaw             string                             `db:"address_raw" `
	AddressID              null.Val[int32]                    `db:"address_id" `
	Created                time.Time                          `db:"created" `
	Location               null.Val[string]                   `db:"location" `
	H3cell                 null.Val[string]                   `db:"h3cell" `
	ID                     int32                              `db:"id,pk" `
	LatlngAccuracyType     enums.PublicreportAccuracytype     `db:"latlng_accuracy_type" `
	LatlngAccuracyValue    float32                            `db:"latlng_accuracy_value" `
	MapZoom                float32                            `db:"map_zoom" `
	OrganizationID         int32                              `db:"organization_id" `
	PublicID               string                             `db:"public_id" `
	ReporterName           string                             `db:"reporter_name" `
	ReporterEmail          string                             `db:"reporter_email" `
	ReporterPhone          string                             `db:"reporter_phone" `
	ReporterContactConsent null.Val[bool]                     `db:"reporter_contact_consent" `
	ReportType             enums.PublicreportReporttype       `db:"report_type" `
	Reviewed               null.Val[time.Time]                `db:"reviewed" `
	ReviewerID             null.Val[int32]                    `db:"reviewer_id" `
	Status                 enums.PublicreportReportstatustype `db:"status" `
	AddressGid             string                             `db:"address_gid" `
	ClientUUID             null.Val[uuid.UUID]                `db:"client_uuid" `
	ReporterPhoneCanSMS    bool                               `db:"reporter_phone_can_sms" `

	R publicreportReportR `db:"-" `
}

// PublicreportReportSlice is an alias for a slice of pointers to PublicreportReport.
// This should almost always be used instead of []*PublicreportReport.
type PublicreportReportSlice []*PublicreportReport

// PublicreportReports contains methods to work with the report table
var PublicreportReports = psql.NewTablex[*PublicreportReport, PublicreportReportSlice, *PublicreportReportSetter]("publicreport", "report", buildPublicreportReportColumns("publicreport.report"))

// PublicreportReportsQuery is a query on the report table
type PublicreportReportsQuery = *psql.ViewQuery[*PublicreportReport, PublicreportReportSlice]

// publicreportReportR is where relationships are stored.
type publicreportReportR struct {
	TextJobs                   CommsTextJobSlice            // comms.text_job.text_job_report_id_fkey
	SourceReportCommunications CommunicationSlice           // communication.communication_source_report_id_fkey
	Compliance                 *PublicreportCompliance      // publicreport.compliance.compliance_report_id_fkey
	NotifyEmails               PublicreportNotifyEmailSlice // publicreport.notify_email.notify_email_report_id_fkey
	NotifyPhones               PublicreportNotifyPhoneSlice // publicreport.notify_phone.notify_phone_report_id_fkey
	Nuisance                   *PublicreportNuisance        // publicreport.nuisance.nuisance_report_id_fkey
	Address                    *Address                     // publicreport.report.report_address_id_fkey
	Client                     *PublicreportClient          // publicreport.report.report_client_uuid_fkey
	Organization               *Organization                // publicreport.report.report_organization_id_fkey
	ReviewerUser               *User                        // publicreport.report.report_reviewer_id_fkey
	Images                     PublicreportImageSlice       // publicreport.report_image.report_image_image_id_fkeypublicreport.report_image.report_image_report_id_fkey
	ReportLogs                 PublicreportReportLogSlice   // publicreport.report_log.report_log_report_id_fkey
	Water                      *PublicreportWater           // publicreport.water.water_report_id_fkey
	ReportTexts                ReportTextSlice              // report_text.report_text_report_id_fkey
	Signals                    SignalSlice                  // signal.signal_report_id_fkey
}

func buildPublicreportReportColumns(alias string) publicreportReportColumns {
	return publicreportReportColumns{
		ColumnsExpr: expr.NewColumnsExpr(
			"address_raw", "address_id", "created", "location", "h3cell", "id", "latlng_accuracy_type", "latlng_accuracy_value", "map_zoom", "organization_id", "public_id", "reporter_name", "reporter_email", "reporter_phone", "reporter_contact_consent", "report_type", "reviewed", "reviewer_id", "status", "address_gid", "client_uuid", "reporter_phone_can_sms",
		).WithParent("publicreport.report"),
		tableAlias:             alias,
		AddressRaw:             psql.Quote(alias, "address_raw"),
		AddressID:              psql.Quote(alias, "address_id"),
		Created:                psql.Quote(alias, "created"),
		Location:               psql.Quote(alias, "location"),
		H3cell:                 psql.Quote(alias, "h3cell"),
		ID:                     psql.Quote(alias, "id"),
		LatlngAccuracyType:     psql.Quote(alias, "latlng_accuracy_type"),
		LatlngAccuracyValue:    psql.Quote(alias, "latlng_accuracy_value"),
		MapZoom:                psql.Quote(alias, "map_zoom"),
		OrganizationID:         psql.Quote(alias, "organization_id"),
		PublicID:               psql.Quote(alias, "public_id"),
		ReporterName:           psql.Quote(alias, "reporter_name"),
		ReporterEmail:          psql.Quote(alias, "reporter_email"),
		ReporterPhone:          psql.Quote(alias, "reporter_phone"),
		ReporterContactConsent: psql.Quote(alias, "reporter_contact_consent"),
		ReportType:             psql.Quote(alias, "report_type"),
		Reviewed:               psql.Quote(alias, "reviewed"),
		ReviewerID:             psql.Quote(alias, "reviewer_id"),
		Status:                 psql.Quote(alias, "status"),
		AddressGid:             psql.Quote(alias, "address_gid"),
		ClientUUID:             psql.Quote(alias, "client_uuid"),
		ReporterPhoneCanSMS:    psql.Quote(alias, "reporter_phone_can_sms"),
	}
}

type publicreportReportColumns struct {
	expr.ColumnsExpr
	tableAlias             string
	AddressRaw             psql.Expression
	AddressID              psql.Expression
	Created                psql.Expression
	Location               psql.Expression
	H3cell                 psql.Expression
	ID                     psql.Expression
	LatlngAccuracyType     psql.Expression
	LatlngAccuracyValue    psql.Expression
	MapZoom                psql.Expression
	OrganizationID         psql.Expression
	PublicID               psql.Expression
	ReporterName           psql.Expression
	ReporterEmail          psql.Expression
	ReporterPhone          psql.Expression
	ReporterContactConsent psql.Expression
	ReportType             psql.Expression
	Reviewed               psql.Expression
	ReviewerID             psql.Expression
	Status                 psql.Expression
	AddressGid             psql.Expression
	ClientUUID             psql.Expression
	ReporterPhoneCanSMS    psql.Expression
}

func (c publicreportReportColumns) Alias() string {
	return c.tableAlias
}

func (publicreportReportColumns) AliasedAs(alias string) publicreportReportColumns {
	return buildPublicreportReportColumns(alias)
}

// PublicreportReportSetter is used for insert/upsert/update operations
// All values are optional, and do not have to be set
// Generated columns are not included
type PublicreportReportSetter struct {
	AddressRaw             omit.Val[string]                             `db:"address_raw" `
	AddressID              omitnull.Val[int32]                          `db:"address_id" `
	Created                omit.Val[time.Time]                          `db:"created" `
	Location               omitnull.Val[string]                         `db:"location" `
	H3cell                 omitnull.Val[string]                         `db:"h3cell" `
	ID                     omit.Val[int32]                              `db:"id,pk" `
	LatlngAccuracyType     omit.Val[enums.PublicreportAccuracytype]     `db:"latlng_accuracy_type" `
	LatlngAccuracyValue    omit.Val[float32]                            `db:"latlng_accuracy_value" `
	MapZoom                omit.Val[float32]                            `db:"map_zoom" `
	OrganizationID         omit.Val[int32]                              `db:"organization_id" `
	PublicID               omit.Val[string]                             `db:"public_id" `
	ReporterName           omit.Val[string]                             `db:"reporter_name" `
	ReporterEmail          omit.Val[string]                             `db:"reporter_email" `
	ReporterPhone          omit.Val[string]                             `db:"reporter_phone" `
	ReporterContactConsent omitnull.Val[bool]                           `db:"reporter_contact_consent" `
	ReportType             omit.Val[enums.PublicreportReporttype]       `db:"report_type" `
	Reviewed               omitnull.Val[time.Time]                      `db:"reviewed" `
	ReviewerID             omitnull.Val[int32]                          `db:"reviewer_id" `
	Status                 omit.Val[enums.PublicreportReportstatustype] `db:"status" `
	AddressGid             omit.Val[string]                             `db:"address_gid" `
	ClientUUID             omitnull.Val[uuid.UUID]                      `db:"client_uuid" `
	ReporterPhoneCanSMS    omit.Val[bool]                               `db:"reporter_phone_can_sms" `
}

func (s PublicreportReportSetter) SetColumns() []string {
	vals := make([]string, 0, 22)
	if s.AddressRaw.IsValue() {
		vals = append(vals, "address_raw")
	}
	if !s.AddressID.IsUnset() {
		vals = append(vals, "address_id")
	}
	if s.Created.IsValue() {
		vals = append(vals, "created")
	}
	if !s.Location.IsUnset() {
		vals = append(vals, "location")
	}
	if !s.H3cell.IsUnset() {
		vals = append(vals, "h3cell")
	}
	if s.ID.IsValue() {
		vals = append(vals, "id")
	}
	if s.LatlngAccuracyType.IsValue() {
		vals = append(vals, "latlng_accuracy_type")
	}
	if s.LatlngAccuracyValue.IsValue() {
		vals = append(vals, "latlng_accuracy_value")
	}
	if s.MapZoom.IsValue() {
		vals = append(vals, "map_zoom")
	}
	if s.OrganizationID.IsValue() {
		vals = append(vals, "organization_id")
	}
	if s.PublicID.IsValue() {
		vals = append(vals, "public_id")
	}
	if s.ReporterName.IsValue() {
		vals = append(vals, "reporter_name")
	}
	if s.ReporterEmail.IsValue() {
		vals = append(vals, "reporter_email")
	}
	if s.ReporterPhone.IsValue() {
		vals = append(vals, "reporter_phone")
	}
	if !s.ReporterContactConsent.IsUnset() {
		vals = append(vals, "reporter_contact_consent")
	}
	if s.ReportType.IsValue() {
		vals = append(vals, "report_type")
	}
	if !s.Reviewed.IsUnset() {
		vals = append(vals, "reviewed")
	}
	if !s.ReviewerID.IsUnset() {
		vals = append(vals, "reviewer_id")
	}
	if s.Status.IsValue() {
		vals = append(vals, "status")
	}
	if s.AddressGid.IsValue() {
		vals = append(vals, "address_gid")
	}
	if !s.ClientUUID.IsUnset() {
		vals = append(vals, "client_uuid")
	}
	if s.ReporterPhoneCanSMS.IsValue() {
		vals = append(vals, "reporter_phone_can_sms")
	}
	return vals
}

func (s PublicreportReportSetter) Overwrite(t *PublicreportReport) {
	if s.AddressRaw.IsValue() {
		t.AddressRaw = s.AddressRaw.MustGet()
	}
	if !s.AddressID.IsUnset() {
		t.AddressID = s.AddressID.MustGetNull()
	}
	if s.Created.IsValue() {
		t.Created = s.Created.MustGet()
	}
	if !s.Location.IsUnset() {
		t.Location = s.Location.MustGetNull()
	}
	if !s.H3cell.IsUnset() {
		t.H3cell = s.H3cell.MustGetNull()
	}
	if s.ID.IsValue() {
		t.ID = s.ID.MustGet()
	}
	if s.LatlngAccuracyType.IsValue() {
		t.LatlngAccuracyType = s.LatlngAccuracyType.MustGet()
	}
	if s.LatlngAccuracyValue.IsValue() {
		t.LatlngAccuracyValue = s.LatlngAccuracyValue.MustGet()
	}
	if s.MapZoom.IsValue() {
		t.MapZoom = s.MapZoom.MustGet()
	}
	if s.OrganizationID.IsValue() {
		t.OrganizationID = s.OrganizationID.MustGet()
	}
	if s.PublicID.IsValue() {
		t.PublicID = s.PublicID.MustGet()
	}
	if s.ReporterName.IsValue() {
		t.ReporterName = s.ReporterName.MustGet()
	}
	if s.ReporterEmail.IsValue() {
		t.ReporterEmail = s.ReporterEmail.MustGet()
	}
	if s.ReporterPhone.IsValue() {
		t.ReporterPhone = s.ReporterPhone.MustGet()
	}
	if !s.ReporterContactConsent.IsUnset() {
		t.ReporterContactConsent = s.ReporterContactConsent.MustGetNull()
	}
	if s.ReportType.IsValue() {
		t.ReportType = s.ReportType.MustGet()
	}
	if !s.Reviewed.IsUnset() {
		t.Reviewed = s.Reviewed.MustGetNull()
	}
	if !s.ReviewerID.IsUnset() {
		t.ReviewerID = s.ReviewerID.MustGetNull()
	}
	if s.Status.IsValue() {
		t.Status = s.Status.MustGet()
	}
	if s.AddressGid.IsValue() {
		t.AddressGid = s.AddressGid.MustGet()
	}
	if !s.ClientUUID.IsUnset() {
		t.ClientUUID = s.ClientUUID.MustGetNull()
	}
	if s.ReporterPhoneCanSMS.IsValue() {
		t.ReporterPhoneCanSMS = s.ReporterPhoneCanSMS.MustGet()
	}
}

func (s *PublicreportReportSetter) Apply(q *dialect.InsertQuery) {
	q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
		return PublicreportReports.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, 22)
		if s.AddressRaw.IsValue() {
			vals[0] = psql.Arg(s.AddressRaw.MustGet())
		} else {
			vals[0] = psql.Raw("DEFAULT")
		}

		if !s.AddressID.IsUnset() {
			vals[1] = psql.Arg(s.AddressID.MustGetNull())
		} 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.Location.IsUnset() {
			vals[3] = psql.Arg(s.Location.MustGetNull())
		} else {
			vals[3] = psql.Raw("DEFAULT")
		}

		if !s.H3cell.IsUnset() {
			vals[4] = psql.Arg(s.H3cell.MustGetNull())
		} else {
			vals[4] = psql.Raw("DEFAULT")
		}

		if s.ID.IsValue() {
			vals[5] = psql.Arg(s.ID.MustGet())
		} else {
			vals[5] = psql.Raw("DEFAULT")
		}

		if s.LatlngAccuracyType.IsValue() {
			vals[6] = psql.Arg(s.LatlngAccuracyType.MustGet())
		} else {
			vals[6] = psql.Raw("DEFAULT")
		}

		if s.LatlngAccuracyValue.IsValue() {
			vals[7] = psql.Arg(s.LatlngAccuracyValue.MustGet())
		} else {
			vals[7] = psql.Raw("DEFAULT")
		}

		if s.MapZoom.IsValue() {
			vals[8] = psql.Arg(s.MapZoom.MustGet())
		} else {
			vals[8] = psql.Raw("DEFAULT")
		}

		if s.OrganizationID.IsValue() {
			vals[9] = psql.Arg(s.OrganizationID.MustGet())
		} else {
			vals[9] = psql.Raw("DEFAULT")
		}

		if s.PublicID.IsValue() {
			vals[10] = psql.Arg(s.PublicID.MustGet())
		} else {
			vals[10] = psql.Raw("DEFAULT")
		}

		if s.ReporterName.IsValue() {
			vals[11] = psql.Arg(s.ReporterName.MustGet())
		} else {
			vals[11] = psql.Raw("DEFAULT")
		}

		if s.ReporterEmail.IsValue() {
			vals[12] = psql.Arg(s.ReporterEmail.MustGet())
		} else {
			vals[12] = psql.Raw("DEFAULT")
		}

		if s.ReporterPhone.IsValue() {
			vals[13] = psql.Arg(s.ReporterPhone.MustGet())
		} else {
			vals[13] = psql.Raw("DEFAULT")
		}

		if !s.ReporterContactConsent.IsUnset() {
			vals[14] = psql.Arg(s.ReporterContactConsent.MustGetNull())
		} else {
			vals[14] = psql.Raw("DEFAULT")
		}

		if s.ReportType.IsValue() {
			vals[15] = psql.Arg(s.ReportType.MustGet())
		} else {
			vals[15] = psql.Raw("DEFAULT")
		}

		if !s.Reviewed.IsUnset() {
			vals[16] = psql.Arg(s.Reviewed.MustGetNull())
		} else {
			vals[16] = psql.Raw("DEFAULT")
		}

		if !s.ReviewerID.IsUnset() {
			vals[17] = psql.Arg(s.ReviewerID.MustGetNull())
		} else {
			vals[17] = psql.Raw("DEFAULT")
		}

		if s.Status.IsValue() {
			vals[18] = psql.Arg(s.Status.MustGet())
		} else {
			vals[18] = psql.Raw("DEFAULT")
		}

		if s.AddressGid.IsValue() {
			vals[19] = psql.Arg(s.AddressGid.MustGet())
		} else {
			vals[19] = psql.Raw("DEFAULT")
		}

		if !s.ClientUUID.IsUnset() {
			vals[20] = psql.Arg(s.ClientUUID.MustGetNull())
		} else {
			vals[20] = psql.Raw("DEFAULT")
		}

		if s.ReporterPhoneCanSMS.IsValue() {
			vals[21] = psql.Arg(s.ReporterPhoneCanSMS.MustGet())
		} else {
			vals[21] = psql.Raw("DEFAULT")
		}

		return bob.ExpressSlice(ctx, w, d, start, vals, "", ", ", "")
	}))
}

func (s PublicreportReportSetter) UpdateMod() bob.Mod[*dialect.UpdateQuery] {
	return um.Set(s.Expressions()...)
}

func (s PublicreportReportSetter) Expressions(prefix ...string) []bob.Expression {
	exprs := make([]bob.Expression, 0, 22)

	if s.AddressRaw.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "address_raw")...),
			psql.Arg(s.AddressRaw),
		}})
	}

	if !s.AddressID.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "address_id")...),
			psql.Arg(s.AddressID),
		}})
	}

	if s.Created.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "created")...),
			psql.Arg(s.Created),
		}})
	}

	if !s.Location.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "location")...),
			psql.Arg(s.Location),
		}})
	}

	if !s.H3cell.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "h3cell")...),
			psql.Arg(s.H3cell),
		}})
	}

	if s.ID.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "id")...),
			psql.Arg(s.ID),
		}})
	}

	if s.LatlngAccuracyType.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "latlng_accuracy_type")...),
			psql.Arg(s.LatlngAccuracyType),
		}})
	}

	if s.LatlngAccuracyValue.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "latlng_accuracy_value")...),
			psql.Arg(s.LatlngAccuracyValue),
		}})
	}

	if s.MapZoom.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "map_zoom")...),
			psql.Arg(s.MapZoom),
		}})
	}

	if s.OrganizationID.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "organization_id")...),
			psql.Arg(s.OrganizationID),
		}})
	}

	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.ReporterName.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reporter_name")...),
			psql.Arg(s.ReporterName),
		}})
	}

	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.ReporterPhone.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reporter_phone")...),
			psql.Arg(s.ReporterPhone),
		}})
	}

	if !s.ReporterContactConsent.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reporter_contact_consent")...),
			psql.Arg(s.ReporterContactConsent),
		}})
	}

	if s.ReportType.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "report_type")...),
			psql.Arg(s.ReportType),
		}})
	}

	if !s.Reviewed.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reviewed")...),
			psql.Arg(s.Reviewed),
		}})
	}

	if !s.ReviewerID.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reviewer_id")...),
			psql.Arg(s.ReviewerID),
		}})
	}

	if s.Status.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "status")...),
			psql.Arg(s.Status),
		}})
	}

	if s.AddressGid.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "address_gid")...),
			psql.Arg(s.AddressGid),
		}})
	}

	if !s.ClientUUID.IsUnset() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "client_uuid")...),
			psql.Arg(s.ClientUUID),
		}})
	}

	if s.ReporterPhoneCanSMS.IsValue() {
		exprs = append(exprs, expr.Join{Sep: " = ", Exprs: []bob.Expression{
			psql.Quote(append(prefix, "reporter_phone_can_sms")...),
			psql.Arg(s.ReporterPhoneCanSMS),
		}})
	}

	return exprs
}

// FindPublicreportReport retrieves a single record by primary key
// If cols is empty Find will return all columns.
func FindPublicreportReport(ctx context.Context, exec bob.Executor, IDPK int32, cols ...string) (*PublicreportReport, error) {
	if len(cols) == 0 {
		return PublicreportReports.Query(
			sm.Where(PublicreportReports.Columns.ID.EQ(psql.Arg(IDPK))),
		).One(ctx, exec)
	}

	return PublicreportReports.Query(
		sm.Where(PublicreportReports.Columns.ID.EQ(psql.Arg(IDPK))),
		sm.Columns(PublicreportReports.Columns.Only(cols...)),
	).One(ctx, exec)
}

// PublicreportReportExists checks the presence of a single record by primary key
func PublicreportReportExists(ctx context.Context, exec bob.Executor, IDPK int32) (bool, error) {
	return PublicreportReports.Query(
		sm.Where(PublicreportReports.Columns.ID.EQ(psql.Arg(IDPK))),
	).Exists(ctx, exec)
}

// AfterQueryHook is called after PublicreportReport is retrieved from the database
func (o *PublicreportReport) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
	var err error

	switch queryType {
	case bob.QueryTypeSelect:
		ctx, err = PublicreportReports.AfterSelectHooks.RunHooks(ctx, exec, PublicreportReportSlice{o})
	case bob.QueryTypeInsert:
		ctx, err = PublicreportReports.AfterInsertHooks.RunHooks(ctx, exec, PublicreportReportSlice{o})
	case bob.QueryTypeUpdate:
		ctx, err = PublicreportReports.AfterUpdateHooks.RunHooks(ctx, exec, PublicreportReportSlice{o})
	case bob.QueryTypeDelete:
		ctx, err = PublicreportReports.AfterDeleteHooks.RunHooks(ctx, exec, PublicreportReportSlice{o})
	}

	return err
}

// primaryKeyVals returns the primary key values of the PublicreportReport
func (o *PublicreportReport) primaryKeyVals() bob.Expression {
	return psql.Arg(o.ID)
}

func (o *PublicreportReport) pkEQ() dialect.Expression {
	return psql.Quote("publicreport.report", "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 PublicreportReport
func (o *PublicreportReport) Update(ctx context.Context, exec bob.Executor, s *PublicreportReportSetter) error {
	v, err := PublicreportReports.Update(s.UpdateMod(), um.Where(o.pkEQ())).One(ctx, exec)
	if err != nil {
		return err
	}

	o.R = v.R
	*o = *v

	return nil
}

// Delete deletes a single PublicreportReport record with an executor
func (o *PublicreportReport) Delete(ctx context.Context, exec bob.Executor) error {
	_, err := PublicreportReports.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
	return err
}

// Reload refreshes the PublicreportReport using the executor
func (o *PublicreportReport) Reload(ctx context.Context, exec bob.Executor) error {
	o2, err := PublicreportReports.Query(
		sm.Where(PublicreportReports.Columns.ID.EQ(psql.Arg(o.ID))),
	).One(ctx, exec)
	if err != nil {
		return err
	}
	o2.R = o.R
	*o = *o2

	return nil
}

// AfterQueryHook is called after PublicreportReportSlice is retrieved from the database
func (o PublicreportReportSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
	var err error

	switch queryType {
	case bob.QueryTypeSelect:
		ctx, err = PublicreportReports.AfterSelectHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeInsert:
		ctx, err = PublicreportReports.AfterInsertHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeUpdate:
		ctx, err = PublicreportReports.AfterUpdateHooks.RunHooks(ctx, exec, o)
	case bob.QueryTypeDelete:
		ctx, err = PublicreportReports.AfterDeleteHooks.RunHooks(ctx, exec, o)
	}

	return err
}

func (o PublicreportReportSlice) pkIN() dialect.Expression {
	if len(o) == 0 {
		return psql.Raw("NULL")
	}

	return psql.Quote("publicreport.report", "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 PublicreportReportSlice) copyMatchingRows(from ...*PublicreportReport) {
	for i, old := range o {
		for _, new := range from {
			if new.ID != old.ID {
				continue
			}
			new.R = old.R
			o[i] = new
			break
		}
	}
}

// UpdateMod modifies an update query with "WHERE primary_key IN (o...)"
func (o PublicreportReportSlice) 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 PublicreportReports.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 *PublicreportReport:
				o.copyMatchingRows(retrieved)
			case []*PublicreportReport:
				o.copyMatchingRows(retrieved...)
			case PublicreportReportSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a PublicreportReport or a slice of PublicreportReport
				// then run the AfterUpdateHooks on the slice
				_, err = PublicreportReports.AfterUpdateHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

		q.AppendWhere(o.pkIN())
	})
}

// DeleteMod modifies an delete query with "WHERE primary_key IN (o...)"
func (o PublicreportReportSlice) 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 PublicreportReports.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 *PublicreportReport:
				o.copyMatchingRows(retrieved)
			case []*PublicreportReport:
				o.copyMatchingRows(retrieved...)
			case PublicreportReportSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a PublicreportReport or a slice of PublicreportReport
				// then run the AfterDeleteHooks on the slice
				_, err = PublicreportReports.AfterDeleteHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

		q.AppendWhere(o.pkIN())
	})
}

func (o PublicreportReportSlice) UpdateAll(ctx context.Context, exec bob.Executor, vals PublicreportReportSetter) error {
	if len(o) == 0 {
		return nil
	}

	_, err := PublicreportReports.Update(vals.UpdateMod(), o.UpdateMod()).All(ctx, exec)
	return err
}

func (o PublicreportReportSlice) DeleteAll(ctx context.Context, exec bob.Executor) error {
	if len(o) == 0 {
		return nil
	}

	_, err := PublicreportReports.Delete(o.DeleteMod()).Exec(ctx, exec)
	return err
}

func (o PublicreportReportSlice) ReloadAll(ctx context.Context, exec bob.Executor) error {
	if len(o) == 0 {
		return nil
	}

	o2, err := PublicreportReports.Query(sm.Where(o.pkIN())).All(ctx, exec)
	if err != nil {
		return err
	}

	o.copyMatchingRows(o2...)

	return nil
}

// TextJobs starts a query for related objects on comms.text_job
func (o *PublicreportReport) TextJobs(mods ...bob.Mod[*dialect.SelectQuery]) CommsTextJobsQuery {
	return CommsTextJobs.Query(append(mods,
		sm.Where(CommsTextJobs.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) TextJobs(mods ...bob.Mod[*dialect.SelectQuery]) CommsTextJobsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return CommsTextJobs.Query(append(mods,
		sm.Where(psql.Group(CommsTextJobs.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// SourceReportCommunications starts a query for related objects on communication
func (o *PublicreportReport) SourceReportCommunications(mods ...bob.Mod[*dialect.SelectQuery]) CommunicationsQuery {
	return Communications.Query(append(mods,
		sm.Where(Communications.Columns.SourceReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) SourceReportCommunications(mods ...bob.Mod[*dialect.SelectQuery]) CommunicationsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return Communications.Query(append(mods,
		sm.Where(psql.Group(Communications.Columns.SourceReportID).OP("IN", PKArgExpr)),
	)...)
}

// Compliance starts a query for related objects on publicreport.compliance
func (o *PublicreportReport) Compliance(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportCompliancesQuery {
	return PublicreportCompliances.Query(append(mods,
		sm.Where(PublicreportCompliances.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) Compliance(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportCompliancesQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportCompliances.Query(append(mods,
		sm.Where(psql.Group(PublicreportCompliances.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// NotifyEmails starts a query for related objects on publicreport.notify_email
func (o *PublicreportReport) NotifyEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailsQuery {
	return PublicreportNotifyEmails.Query(append(mods,
		sm.Where(PublicreportNotifyEmails.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) NotifyEmails(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyEmailsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportNotifyEmails.Query(append(mods,
		sm.Where(psql.Group(PublicreportNotifyEmails.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// NotifyPhones starts a query for related objects on publicreport.notify_phone
func (o *PublicreportReport) NotifyPhones(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyPhonesQuery {
	return PublicreportNotifyPhones.Query(append(mods,
		sm.Where(PublicreportNotifyPhones.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) NotifyPhones(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNotifyPhonesQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportNotifyPhones.Query(append(mods,
		sm.Where(psql.Group(PublicreportNotifyPhones.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// Nuisance starts a query for related objects on publicreport.nuisance
func (o *PublicreportReport) Nuisance(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNuisancesQuery {
	return PublicreportNuisances.Query(append(mods,
		sm.Where(PublicreportNuisances.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) Nuisance(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportNuisancesQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportNuisances.Query(append(mods,
		sm.Where(psql.Group(PublicreportNuisances.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// Address starts a query for related objects on address
func (o *PublicreportReport) Address(mods ...bob.Mod[*dialect.SelectQuery]) AddressesQuery {
	return Addresses.Query(append(mods,
		sm.Where(Addresses.Columns.ID.EQ(psql.Arg(o.AddressID))),
	)...)
}

func (os PublicreportReportSlice) Address(mods ...bob.Mod[*dialect.SelectQuery]) AddressesQuery {
	pkAddressID := make(pgtypes.Array[null.Val[int32]], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkAddressID = append(pkAddressID, o.AddressID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkAddressID), "integer[]")),
	))

	return Addresses.Query(append(mods,
		sm.Where(psql.Group(Addresses.Columns.ID).OP("IN", PKArgExpr)),
	)...)
}

// Client starts a query for related objects on publicreport.client
func (o *PublicreportReport) Client(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportClientsQuery {
	return PublicreportClients.Query(append(mods,
		sm.Where(PublicreportClients.Columns.UUID.EQ(psql.Arg(o.ClientUUID))),
	)...)
}

func (os PublicreportReportSlice) Client(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportClientsQuery {
	pkClientUUID := make(pgtypes.Array[null.Val[uuid.UUID]], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkClientUUID = append(pkClientUUID, o.ClientUUID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkClientUUID), "uuid[]")),
	))

	return PublicreportClients.Query(append(mods,
		sm.Where(psql.Group(PublicreportClients.Columns.UUID).OP("IN", PKArgExpr)),
	)...)
}

// Organization starts a query for related objects on organization
func (o *PublicreportReport) Organization(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	return Organizations.Query(append(mods,
		sm.Where(Organizations.Columns.ID.EQ(psql.Arg(o.OrganizationID))),
	)...)
}

func (os PublicreportReportSlice) Organization(mods ...bob.Mod[*dialect.SelectQuery]) OrganizationsQuery {
	pkOrganizationID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkOrganizationID = append(pkOrganizationID, o.OrganizationID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkOrganizationID), "integer[]")),
	))

	return Organizations.Query(append(mods,
		sm.Where(psql.Group(Organizations.Columns.ID).OP("IN", PKArgExpr)),
	)...)
}

// ReviewerUser starts a query for related objects on user_
func (o *PublicreportReport) ReviewerUser(mods ...bob.Mod[*dialect.SelectQuery]) UsersQuery {
	return Users.Query(append(mods,
		sm.Where(Users.Columns.ID.EQ(psql.Arg(o.ReviewerID))),
	)...)
}

func (os PublicreportReportSlice) ReviewerUser(mods ...bob.Mod[*dialect.SelectQuery]) UsersQuery {
	pkReviewerID := make(pgtypes.Array[null.Val[int32]], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkReviewerID = append(pkReviewerID, o.ReviewerID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkReviewerID), "integer[]")),
	))

	return Users.Query(append(mods,
		sm.Where(psql.Group(Users.Columns.ID).OP("IN", PKArgExpr)),
	)...)
}

// Images starts a query for related objects on publicreport.image
func (o *PublicreportReport) Images(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportImagesQuery {
	return PublicreportImages.Query(append(mods,
		sm.InnerJoin(PublicreportReportImages.NameAs()).On(
			PublicreportImages.Columns.ID.EQ(PublicreportReportImages.Columns.ImageID)),
		sm.Where(PublicreportReportImages.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) Images(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportImagesQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportImages.Query(append(mods,
		sm.InnerJoin(PublicreportReportImages.NameAs()).On(
			PublicreportImages.Columns.ID.EQ(PublicreportReportImages.Columns.ImageID),
		),
		sm.Where(psql.Group(PublicreportReportImages.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// ReportLogs starts a query for related objects on publicreport.report_log
func (o *PublicreportReport) ReportLogs(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportReportLogsQuery {
	return PublicreportReportLogs.Query(append(mods,
		sm.Where(PublicreportReportLogs.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) ReportLogs(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportReportLogsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportReportLogs.Query(append(mods,
		sm.Where(psql.Group(PublicreportReportLogs.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// Water starts a query for related objects on publicreport.water
func (o *PublicreportReport) Water(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportWatersQuery {
	return PublicreportWaters.Query(append(mods,
		sm.Where(PublicreportWaters.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) Water(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportWatersQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return PublicreportWaters.Query(append(mods,
		sm.Where(psql.Group(PublicreportWaters.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// ReportTexts starts a query for related objects on report_text
func (o *PublicreportReport) ReportTexts(mods ...bob.Mod[*dialect.SelectQuery]) ReportTextsQuery {
	return ReportTexts.Query(append(mods,
		sm.Where(ReportTexts.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) ReportTexts(mods ...bob.Mod[*dialect.SelectQuery]) ReportTextsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return ReportTexts.Query(append(mods,
		sm.Where(psql.Group(ReportTexts.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

// Signals starts a query for related objects on signal
func (o *PublicreportReport) Signals(mods ...bob.Mod[*dialect.SelectQuery]) SignalsQuery {
	return Signals.Query(append(mods,
		sm.Where(Signals.Columns.ReportID.EQ(psql.Arg(o.ID))),
	)...)
}

func (os PublicreportReportSlice) Signals(mods ...bob.Mod[*dialect.SelectQuery]) SignalsQuery {
	pkID := make(pgtypes.Array[int32], 0, len(os))
	for _, o := range os {
		if o == nil {
			continue
		}
		pkID = append(pkID, o.ID)
	}
	PKArgExpr := psql.Select(sm.Columns(
		psql.F("unnest", psql.Cast(psql.Arg(pkID), "integer[]")),
	))

	return Signals.Query(append(mods,
		sm.Where(psql.Group(Signals.Columns.ReportID).OP("IN", PKArgExpr)),
	)...)
}

func insertPublicreportReportTextJobs0(ctx context.Context, exec bob.Executor, commsTextJobs1 []*CommsTextJobSetter, publicreportReport0 *PublicreportReport) (CommsTextJobSlice, error) {
	for i := range commsTextJobs1 {
		commsTextJobs1[i].ReportID = omitnull.From(publicreportReport0.ID)
	}

	ret, err := CommsTextJobs.Insert(bob.ToMods(commsTextJobs1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportTextJobs0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportTextJobs0(ctx context.Context, exec bob.Executor, count int, commsTextJobs1 CommsTextJobSlice, publicreportReport0 *PublicreportReport) (CommsTextJobSlice, error) {
	setter := &CommsTextJobSetter{
		ReportID: omitnull.From(publicreportReport0.ID),
	}

	err := commsTextJobs1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportTextJobs0: %w", err)
	}

	return commsTextJobs1, nil
}

func (publicreportReport0 *PublicreportReport) InsertTextJobs(ctx context.Context, exec bob.Executor, related ...*CommsTextJobSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	commsTextJobs1, err := insertPublicreportReportTextJobs0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.TextJobs = append(publicreportReport0.R.TextJobs, commsTextJobs1...)

	for _, rel := range commsTextJobs1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachTextJobs(ctx context.Context, exec bob.Executor, related ...*CommsTextJob) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	commsTextJobs1 := CommsTextJobSlice(related)

	_, err = attachPublicreportReportTextJobs0(ctx, exec, len(related), commsTextJobs1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.TextJobs = append(publicreportReport0.R.TextJobs, commsTextJobs1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

func insertPublicreportReportSourceReportCommunications0(ctx context.Context, exec bob.Executor, communications1 []*CommunicationSetter, publicreportReport0 *PublicreportReport) (CommunicationSlice, error) {
	for i := range communications1 {
		communications1[i].SourceReportID = omitnull.From(publicreportReport0.ID)
	}

	ret, err := Communications.Insert(bob.ToMods(communications1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportSourceReportCommunications0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportSourceReportCommunications0(ctx context.Context, exec bob.Executor, count int, communications1 CommunicationSlice, publicreportReport0 *PublicreportReport) (CommunicationSlice, error) {
	setter := &CommunicationSetter{
		SourceReportID: omitnull.From(publicreportReport0.ID),
	}

	err := communications1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportSourceReportCommunications0: %w", err)
	}

	return communications1, nil
}

func (publicreportReport0 *PublicreportReport) InsertSourceReportCommunications(ctx context.Context, exec bob.Executor, related ...*CommunicationSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	communications1, err := insertPublicreportReportSourceReportCommunications0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.SourceReportCommunications = append(publicreportReport0.R.SourceReportCommunications, communications1...)

	for _, rel := range communications1 {
		rel.R.SourceReportReport = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachSourceReportCommunications(ctx context.Context, exec bob.Executor, related ...*Communication) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	communications1 := CommunicationSlice(related)

	_, err = attachPublicreportReportSourceReportCommunications0(ctx, exec, len(related), communications1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.SourceReportCommunications = append(publicreportReport0.R.SourceReportCommunications, communications1...)

	for _, rel := range related {
		rel.R.SourceReportReport = publicreportReport0
	}

	return nil
}

func insertPublicreportReportCompliance0(ctx context.Context, exec bob.Executor, publicreportCompliance1 *PublicreportComplianceSetter, publicreportReport0 *PublicreportReport) (*PublicreportCompliance, error) {
	publicreportCompliance1.ReportID = omit.From(publicreportReport0.ID)

	ret, err := PublicreportCompliances.Insert(publicreportCompliance1).One(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportCompliance0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportCompliance0(ctx context.Context, exec bob.Executor, count int, publicreportCompliance1 *PublicreportCompliance, publicreportReport0 *PublicreportReport) (*PublicreportCompliance, error) {
	setter := &PublicreportComplianceSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportCompliance1.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportCompliance0: %w", err)
	}

	return publicreportCompliance1, nil
}

func (publicreportReport0 *PublicreportReport) InsertCompliance(ctx context.Context, exec bob.Executor, related *PublicreportComplianceSetter) error {
	var err error

	publicreportCompliance1, err := insertPublicreportReportCompliance0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Compliance = publicreportCompliance1

	publicreportCompliance1.R.Report = publicreportReport0

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachCompliance(ctx context.Context, exec bob.Executor, publicreportCompliance1 *PublicreportCompliance) error {
	var err error

	_, err = attachPublicreportReportCompliance0(ctx, exec, 1, publicreportCompliance1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Compliance = publicreportCompliance1

	publicreportCompliance1.R.Report = publicreportReport0

	return nil
}

func insertPublicreportReportNotifyEmails0(ctx context.Context, exec bob.Executor, publicreportNotifyEmails1 []*PublicreportNotifyEmailSetter, publicreportReport0 *PublicreportReport) (PublicreportNotifyEmailSlice, error) {
	for i := range publicreportNotifyEmails1 {
		publicreportNotifyEmails1[i].ReportID = omit.From(publicreportReport0.ID)
	}

	ret, err := PublicreportNotifyEmails.Insert(bob.ToMods(publicreportNotifyEmails1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportNotifyEmails0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportNotifyEmails0(ctx context.Context, exec bob.Executor, count int, publicreportNotifyEmails1 PublicreportNotifyEmailSlice, publicreportReport0 *PublicreportReport) (PublicreportNotifyEmailSlice, error) {
	setter := &PublicreportNotifyEmailSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportNotifyEmails1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportNotifyEmails0: %w", err)
	}

	return publicreportNotifyEmails1, nil
}

func (publicreportReport0 *PublicreportReport) InsertNotifyEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmailSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportNotifyEmails1, err := insertPublicreportReportNotifyEmails0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.NotifyEmails = append(publicreportReport0.R.NotifyEmails, publicreportNotifyEmails1...)

	for _, rel := range publicreportNotifyEmails1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachNotifyEmails(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyEmail) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportNotifyEmails1 := PublicreportNotifyEmailSlice(related)

	_, err = attachPublicreportReportNotifyEmails0(ctx, exec, len(related), publicreportNotifyEmails1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.NotifyEmails = append(publicreportReport0.R.NotifyEmails, publicreportNotifyEmails1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

func insertPublicreportReportNotifyPhones0(ctx context.Context, exec bob.Executor, publicreportNotifyPhones1 []*PublicreportNotifyPhoneSetter, publicreportReport0 *PublicreportReport) (PublicreportNotifyPhoneSlice, error) {
	for i := range publicreportNotifyPhones1 {
		publicreportNotifyPhones1[i].ReportID = omit.From(publicreportReport0.ID)
	}

	ret, err := PublicreportNotifyPhones.Insert(bob.ToMods(publicreportNotifyPhones1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportNotifyPhones0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportNotifyPhones0(ctx context.Context, exec bob.Executor, count int, publicreportNotifyPhones1 PublicreportNotifyPhoneSlice, publicreportReport0 *PublicreportReport) (PublicreportNotifyPhoneSlice, error) {
	setter := &PublicreportNotifyPhoneSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportNotifyPhones1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportNotifyPhones0: %w", err)
	}

	return publicreportNotifyPhones1, nil
}

func (publicreportReport0 *PublicreportReport) InsertNotifyPhones(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyPhoneSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportNotifyPhones1, err := insertPublicreportReportNotifyPhones0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.NotifyPhones = append(publicreportReport0.R.NotifyPhones, publicreportNotifyPhones1...)

	for _, rel := range publicreportNotifyPhones1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachNotifyPhones(ctx context.Context, exec bob.Executor, related ...*PublicreportNotifyPhone) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportNotifyPhones1 := PublicreportNotifyPhoneSlice(related)

	_, err = attachPublicreportReportNotifyPhones0(ctx, exec, len(related), publicreportNotifyPhones1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.NotifyPhones = append(publicreportReport0.R.NotifyPhones, publicreportNotifyPhones1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

func insertPublicreportReportNuisance0(ctx context.Context, exec bob.Executor, publicreportNuisance1 *PublicreportNuisanceSetter, publicreportReport0 *PublicreportReport) (*PublicreportNuisance, error) {
	publicreportNuisance1.ReportID = omit.From(publicreportReport0.ID)

	ret, err := PublicreportNuisances.Insert(publicreportNuisance1).One(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportNuisance0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportNuisance0(ctx context.Context, exec bob.Executor, count int, publicreportNuisance1 *PublicreportNuisance, publicreportReport0 *PublicreportReport) (*PublicreportNuisance, error) {
	setter := &PublicreportNuisanceSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportNuisance1.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportNuisance0: %w", err)
	}

	return publicreportNuisance1, nil
}

func (publicreportReport0 *PublicreportReport) InsertNuisance(ctx context.Context, exec bob.Executor, related *PublicreportNuisanceSetter) error {
	var err error

	publicreportNuisance1, err := insertPublicreportReportNuisance0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Nuisance = publicreportNuisance1

	publicreportNuisance1.R.Report = publicreportReport0

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachNuisance(ctx context.Context, exec bob.Executor, publicreportNuisance1 *PublicreportNuisance) error {
	var err error

	_, err = attachPublicreportReportNuisance0(ctx, exec, 1, publicreportNuisance1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Nuisance = publicreportNuisance1

	publicreportNuisance1.R.Report = publicreportReport0

	return nil
}

func attachPublicreportReportAddress0(ctx context.Context, exec bob.Executor, count int, publicreportReport0 *PublicreportReport, address1 *Address) (*PublicreportReport, error) {
	setter := &PublicreportReportSetter{
		AddressID: omitnull.From(address1.ID),
	}

	err := publicreportReport0.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportAddress0: %w", err)
	}

	return publicreportReport0, nil
}

func (publicreportReport0 *PublicreportReport) InsertAddress(ctx context.Context, exec bob.Executor, related *AddressSetter) error {
	var err error

	address1, err := Addresses.Insert(related).One(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}

	_, err = attachPublicreportReportAddress0(ctx, exec, 1, publicreportReport0, address1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Address = address1

	address1.R.Reports = append(address1.R.Reports, publicreportReport0)

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachAddress(ctx context.Context, exec bob.Executor, address1 *Address) error {
	var err error

	_, err = attachPublicreportReportAddress0(ctx, exec, 1, publicreportReport0, address1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Address = address1

	address1.R.Reports = append(address1.R.Reports, publicreportReport0)

	return nil
}

func attachPublicreportReportClient0(ctx context.Context, exec bob.Executor, count int, publicreportReport0 *PublicreportReport, publicreportClient1 *PublicreportClient) (*PublicreportReport, error) {
	setter := &PublicreportReportSetter{
		ClientUUID: omitnull.From(publicreportClient1.UUID),
	}

	err := publicreportReport0.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportClient0: %w", err)
	}

	return publicreportReport0, nil
}

func (publicreportReport0 *PublicreportReport) InsertClient(ctx context.Context, exec bob.Executor, related *PublicreportClientSetter) error {
	var err error

	publicreportClient1, err := PublicreportClients.Insert(related).One(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}

	_, err = attachPublicreportReportClient0(ctx, exec, 1, publicreportReport0, publicreportClient1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Client = publicreportClient1

	publicreportClient1.R.Reports = append(publicreportClient1.R.Reports, publicreportReport0)

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachClient(ctx context.Context, exec bob.Executor, publicreportClient1 *PublicreportClient) error {
	var err error

	_, err = attachPublicreportReportClient0(ctx, exec, 1, publicreportReport0, publicreportClient1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Client = publicreportClient1

	publicreportClient1.R.Reports = append(publicreportClient1.R.Reports, publicreportReport0)

	return nil
}

func attachPublicreportReportOrganization0(ctx context.Context, exec bob.Executor, count int, publicreportReport0 *PublicreportReport, organization1 *Organization) (*PublicreportReport, error) {
	setter := &PublicreportReportSetter{
		OrganizationID: omit.From(organization1.ID),
	}

	err := publicreportReport0.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportOrganization0: %w", err)
	}

	return publicreportReport0, nil
}

func (publicreportReport0 *PublicreportReport) InsertOrganization(ctx context.Context, exec bob.Executor, related *OrganizationSetter) error {
	var err error

	organization1, err := Organizations.Insert(related).One(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}

	_, err = attachPublicreportReportOrganization0(ctx, exec, 1, publicreportReport0, organization1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Organization = organization1

	organization1.R.Reports = append(organization1.R.Reports, publicreportReport0)

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachOrganization(ctx context.Context, exec bob.Executor, organization1 *Organization) error {
	var err error

	_, err = attachPublicreportReportOrganization0(ctx, exec, 1, publicreportReport0, organization1)
	if err != nil {
		return err
	}

	publicreportReport0.R.Organization = organization1

	organization1.R.Reports = append(organization1.R.Reports, publicreportReport0)

	return nil
}

func attachPublicreportReportReviewerUser0(ctx context.Context, exec bob.Executor, count int, publicreportReport0 *PublicreportReport, user1 *User) (*PublicreportReport, error) {
	setter := &PublicreportReportSetter{
		ReviewerID: omitnull.From(user1.ID),
	}

	err := publicreportReport0.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportReviewerUser0: %w", err)
	}

	return publicreportReport0, nil
}

func (publicreportReport0 *PublicreportReport) InsertReviewerUser(ctx context.Context, exec bob.Executor, related *UserSetter) error {
	var err error

	user1, err := Users.Insert(related).One(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}

	_, err = attachPublicreportReportReviewerUser0(ctx, exec, 1, publicreportReport0, user1)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReviewerUser = user1

	user1.R.ReviewerReports = append(user1.R.ReviewerReports, publicreportReport0)

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachReviewerUser(ctx context.Context, exec bob.Executor, user1 *User) error {
	var err error

	_, err = attachPublicreportReportReviewerUser0(ctx, exec, 1, publicreportReport0, user1)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReviewerUser = user1

	user1.R.ReviewerReports = append(user1.R.ReviewerReports, publicreportReport0)

	return nil
}

func attachPublicreportReportImages0(ctx context.Context, exec bob.Executor, count int, publicreportReport0 *PublicreportReport, publicreportImages2 PublicreportImageSlice) (PublicreportReportImageSlice, error) {
	setters := make([]*PublicreportReportImageSetter, count)
	for i := range count {
		setters[i] = &PublicreportReportImageSetter{
			ReportID: omit.From(publicreportReport0.ID),
			ImageID:  omit.From(publicreportImages2[i].ID),
		}
	}

	publicreportReportImages1, err := PublicreportReportImages.Insert(bob.ToMods(setters...)).All(ctx, exec)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportImages0: %w", err)
	}

	return publicreportReportImages1, nil
}

func (publicreportReport0 *PublicreportReport) InsertImages(ctx context.Context, exec bob.Executor, related ...*PublicreportImageSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	inserted, err := PublicreportImages.Insert(bob.ToMods(related...)).All(ctx, exec)
	if err != nil {
		return fmt.Errorf("inserting related objects: %w", err)
	}
	publicreportImages2 := PublicreportImageSlice(inserted)

	_, err = attachPublicreportReportImages0(ctx, exec, len(related), publicreportReport0, publicreportImages2)
	if err != nil {
		return err
	}

	publicreportReport0.R.Images = append(publicreportReport0.R.Images, publicreportImages2...)

	for _, rel := range publicreportImages2 {
		rel.R.Reports = append(rel.R.Reports, publicreportReport0)
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachImages(ctx context.Context, exec bob.Executor, related ...*PublicreportImage) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportImages2 := PublicreportImageSlice(related)

	_, err = attachPublicreportReportImages0(ctx, exec, len(related), publicreportReport0, publicreportImages2)
	if err != nil {
		return err
	}

	publicreportReport0.R.Images = append(publicreportReport0.R.Images, publicreportImages2...)

	for _, rel := range related {
		rel.R.Reports = append(rel.R.Reports, publicreportReport0)
	}

	return nil
}

func insertPublicreportReportReportLogs0(ctx context.Context, exec bob.Executor, publicreportReportLogs1 []*PublicreportReportLogSetter, publicreportReport0 *PublicreportReport) (PublicreportReportLogSlice, error) {
	for i := range publicreportReportLogs1 {
		publicreportReportLogs1[i].ReportID = omit.From(publicreportReport0.ID)
	}

	ret, err := PublicreportReportLogs.Insert(bob.ToMods(publicreportReportLogs1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportReportLogs0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportReportLogs0(ctx context.Context, exec bob.Executor, count int, publicreportReportLogs1 PublicreportReportLogSlice, publicreportReport0 *PublicreportReport) (PublicreportReportLogSlice, error) {
	setter := &PublicreportReportLogSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportReportLogs1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportReportLogs0: %w", err)
	}

	return publicreportReportLogs1, nil
}

func (publicreportReport0 *PublicreportReport) InsertReportLogs(ctx context.Context, exec bob.Executor, related ...*PublicreportReportLogSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	publicreportReportLogs1, err := insertPublicreportReportReportLogs0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReportLogs = append(publicreportReport0.R.ReportLogs, publicreportReportLogs1...)

	for _, rel := range publicreportReportLogs1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachReportLogs(ctx context.Context, exec bob.Executor, related ...*PublicreportReportLog) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	publicreportReportLogs1 := PublicreportReportLogSlice(related)

	_, err = attachPublicreportReportReportLogs0(ctx, exec, len(related), publicreportReportLogs1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReportLogs = append(publicreportReport0.R.ReportLogs, publicreportReportLogs1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

func insertPublicreportReportWater0(ctx context.Context, exec bob.Executor, publicreportWater1 *PublicreportWaterSetter, publicreportReport0 *PublicreportReport) (*PublicreportWater, error) {
	publicreportWater1.ReportID = omit.From(publicreportReport0.ID)

	ret, err := PublicreportWaters.Insert(publicreportWater1).One(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportWater0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportWater0(ctx context.Context, exec bob.Executor, count int, publicreportWater1 *PublicreportWater, publicreportReport0 *PublicreportReport) (*PublicreportWater, error) {
	setter := &PublicreportWaterSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := publicreportWater1.Update(ctx, exec, setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportWater0: %w", err)
	}

	return publicreportWater1, nil
}

func (publicreportReport0 *PublicreportReport) InsertWater(ctx context.Context, exec bob.Executor, related *PublicreportWaterSetter) error {
	var err error

	publicreportWater1, err := insertPublicreportReportWater0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Water = publicreportWater1

	publicreportWater1.R.Report = publicreportReport0

	return nil
}

func (publicreportReport0 *PublicreportReport) AttachWater(ctx context.Context, exec bob.Executor, publicreportWater1 *PublicreportWater) error {
	var err error

	_, err = attachPublicreportReportWater0(ctx, exec, 1, publicreportWater1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Water = publicreportWater1

	publicreportWater1.R.Report = publicreportReport0

	return nil
}

func insertPublicreportReportReportTexts0(ctx context.Context, exec bob.Executor, reportTexts1 []*ReportTextSetter, publicreportReport0 *PublicreportReport) (ReportTextSlice, error) {
	for i := range reportTexts1 {
		reportTexts1[i].ReportID = omit.From(publicreportReport0.ID)
	}

	ret, err := ReportTexts.Insert(bob.ToMods(reportTexts1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportReportTexts0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportReportTexts0(ctx context.Context, exec bob.Executor, count int, reportTexts1 ReportTextSlice, publicreportReport0 *PublicreportReport) (ReportTextSlice, error) {
	setter := &ReportTextSetter{
		ReportID: omit.From(publicreportReport0.ID),
	}

	err := reportTexts1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportReportTexts0: %w", err)
	}

	return reportTexts1, nil
}

func (publicreportReport0 *PublicreportReport) InsertReportTexts(ctx context.Context, exec bob.Executor, related ...*ReportTextSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	reportTexts1, err := insertPublicreportReportReportTexts0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReportTexts = append(publicreportReport0.R.ReportTexts, reportTexts1...)

	for _, rel := range reportTexts1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachReportTexts(ctx context.Context, exec bob.Executor, related ...*ReportText) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	reportTexts1 := ReportTextSlice(related)

	_, err = attachPublicreportReportReportTexts0(ctx, exec, len(related), reportTexts1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.ReportTexts = append(publicreportReport0.R.ReportTexts, reportTexts1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

func insertPublicreportReportSignals0(ctx context.Context, exec bob.Executor, signals1 []*SignalSetter, publicreportReport0 *PublicreportReport) (SignalSlice, error) {
	for i := range signals1 {
		signals1[i].ReportID = omitnull.From(publicreportReport0.ID)
	}

	ret, err := Signals.Insert(bob.ToMods(signals1...)).All(ctx, exec)
	if err != nil {
		return ret, fmt.Errorf("insertPublicreportReportSignals0: %w", err)
	}

	return ret, nil
}

func attachPublicreportReportSignals0(ctx context.Context, exec bob.Executor, count int, signals1 SignalSlice, publicreportReport0 *PublicreportReport) (SignalSlice, error) {
	setter := &SignalSetter{
		ReportID: omitnull.From(publicreportReport0.ID),
	}

	err := signals1.UpdateAll(ctx, exec, *setter)
	if err != nil {
		return nil, fmt.Errorf("attachPublicreportReportSignals0: %w", err)
	}

	return signals1, nil
}

func (publicreportReport0 *PublicreportReport) InsertSignals(ctx context.Context, exec bob.Executor, related ...*SignalSetter) error {
	if len(related) == 0 {
		return nil
	}

	var err error

	signals1, err := insertPublicreportReportSignals0(ctx, exec, related, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Signals = append(publicreportReport0.R.Signals, signals1...)

	for _, rel := range signals1 {
		rel.R.Report = publicreportReport0
	}
	return nil
}

func (publicreportReport0 *PublicreportReport) AttachSignals(ctx context.Context, exec bob.Executor, related ...*Signal) error {
	if len(related) == 0 {
		return nil
	}

	var err error
	signals1 := SignalSlice(related)

	_, err = attachPublicreportReportSignals0(ctx, exec, len(related), signals1, publicreportReport0)
	if err != nil {
		return err
	}

	publicreportReport0.R.Signals = append(publicreportReport0.R.Signals, signals1...)

	for _, rel := range related {
		rel.R.Report = publicreportReport0
	}

	return nil
}

type publicreportReportWhere[Q psql.Filterable] struct {
	AddressRaw             psql.WhereMod[Q, string]
	AddressID              psql.WhereNullMod[Q, int32]
	Created                psql.WhereMod[Q, time.Time]
	Location               psql.WhereNullMod[Q, string]
	H3cell                 psql.WhereNullMod[Q, string]
	ID                     psql.WhereMod[Q, int32]
	LatlngAccuracyType     psql.WhereMod[Q, enums.PublicreportAccuracytype]
	LatlngAccuracyValue    psql.WhereMod[Q, float32]
	MapZoom                psql.WhereMod[Q, float32]
	OrganizationID         psql.WhereMod[Q, int32]
	PublicID               psql.WhereMod[Q, string]
	ReporterName           psql.WhereMod[Q, string]
	ReporterEmail          psql.WhereMod[Q, string]
	ReporterPhone          psql.WhereMod[Q, string]
	ReporterContactConsent psql.WhereNullMod[Q, bool]
	ReportType             psql.WhereMod[Q, enums.PublicreportReporttype]
	Reviewed               psql.WhereNullMod[Q, time.Time]
	ReviewerID             psql.WhereNullMod[Q, int32]
	Status                 psql.WhereMod[Q, enums.PublicreportReportstatustype]
	AddressGid             psql.WhereMod[Q, string]
	ClientUUID             psql.WhereNullMod[Q, uuid.UUID]
	ReporterPhoneCanSMS    psql.WhereMod[Q, bool]
}

func (publicreportReportWhere[Q]) AliasedAs(alias string) publicreportReportWhere[Q] {
	return buildPublicreportReportWhere[Q](buildPublicreportReportColumns(alias))
}

func buildPublicreportReportWhere[Q psql.Filterable](cols publicreportReportColumns) publicreportReportWhere[Q] {
	return publicreportReportWhere[Q]{
		AddressRaw:             psql.Where[Q, string](cols.AddressRaw),
		AddressID:              psql.WhereNull[Q, int32](cols.AddressID),
		Created:                psql.Where[Q, time.Time](cols.Created),
		Location:               psql.WhereNull[Q, string](cols.Location),
		H3cell:                 psql.WhereNull[Q, string](cols.H3cell),
		ID:                     psql.Where[Q, int32](cols.ID),
		LatlngAccuracyType:     psql.Where[Q, enums.PublicreportAccuracytype](cols.LatlngAccuracyType),
		LatlngAccuracyValue:    psql.Where[Q, float32](cols.LatlngAccuracyValue),
		MapZoom:                psql.Where[Q, float32](cols.MapZoom),
		OrganizationID:         psql.Where[Q, int32](cols.OrganizationID),
		PublicID:               psql.Where[Q, string](cols.PublicID),
		ReporterName:           psql.Where[Q, string](cols.ReporterName),
		ReporterEmail:          psql.Where[Q, string](cols.ReporterEmail),
		ReporterPhone:          psql.Where[Q, string](cols.ReporterPhone),
		ReporterContactConsent: psql.WhereNull[Q, bool](cols.ReporterContactConsent),
		ReportType:             psql.Where[Q, enums.PublicreportReporttype](cols.ReportType),
		Reviewed:               psql.WhereNull[Q, time.Time](cols.Reviewed),
		ReviewerID:             psql.WhereNull[Q, int32](cols.ReviewerID),
		Status:                 psql.Where[Q, enums.PublicreportReportstatustype](cols.Status),
		AddressGid:             psql.Where[Q, string](cols.AddressGid),
		ClientUUID:             psql.WhereNull[Q, uuid.UUID](cols.ClientUUID),
		ReporterPhoneCanSMS:    psql.Where[Q, bool](cols.ReporterPhoneCanSMS),
	}
}

func (o *PublicreportReport) Preload(name string, retrieved any) error {
	if o == nil {
		return nil
	}

	switch name {
	case "TextJobs":
		rels, ok := retrieved.(CommsTextJobSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.TextJobs = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	case "SourceReportCommunications":
		rels, ok := retrieved.(CommunicationSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.SourceReportCommunications = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.SourceReportReport = o
			}
		}
		return nil
	case "Compliance":
		rel, ok := retrieved.(*PublicreportCompliance)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Compliance = rel

		if rel != nil {
			rel.R.Report = o
		}
		return nil
	case "NotifyEmails":
		rels, ok := retrieved.(PublicreportNotifyEmailSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.NotifyEmails = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	case "NotifyPhones":
		rels, ok := retrieved.(PublicreportNotifyPhoneSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.NotifyPhones = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	case "Nuisance":
		rel, ok := retrieved.(*PublicreportNuisance)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Nuisance = rel

		if rel != nil {
			rel.R.Report = o
		}
		return nil
	case "Address":
		rel, ok := retrieved.(*Address)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Address = rel

		if rel != nil {
			rel.R.Reports = PublicreportReportSlice{o}
		}
		return nil
	case "Client":
		rel, ok := retrieved.(*PublicreportClient)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Client = rel

		if rel != nil {
			rel.R.Reports = PublicreportReportSlice{o}
		}
		return nil
	case "Organization":
		rel, ok := retrieved.(*Organization)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Organization = rel

		if rel != nil {
			rel.R.Reports = PublicreportReportSlice{o}
		}
		return nil
	case "ReviewerUser":
		rel, ok := retrieved.(*User)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.ReviewerUser = rel

		if rel != nil {
			rel.R.ReviewerReports = PublicreportReportSlice{o}
		}
		return nil
	case "Images":
		rels, ok := retrieved.(PublicreportImageSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Images = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Reports = PublicreportReportSlice{o}
			}
		}
		return nil
	case "ReportLogs":
		rels, ok := retrieved.(PublicreportReportLogSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.ReportLogs = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	case "Water":
		rel, ok := retrieved.(*PublicreportWater)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Water = rel

		if rel != nil {
			rel.R.Report = o
		}
		return nil
	case "ReportTexts":
		rels, ok := retrieved.(ReportTextSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.ReportTexts = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	case "Signals":
		rels, ok := retrieved.(SignalSlice)
		if !ok {
			return fmt.Errorf("publicreportReport cannot load %T as %q", retrieved, name)
		}

		o.R.Signals = rels

		for _, rel := range rels {
			if rel != nil {
				rel.R.Report = o
			}
		}
		return nil
	default:
		return fmt.Errorf("publicreportReport has no relationship %q", name)
	}
}

type publicreportReportPreloader struct {
	Compliance   func(...psql.PreloadOption) psql.Preloader
	Nuisance     func(...psql.PreloadOption) psql.Preloader
	Address      func(...psql.PreloadOption) psql.Preloader
	Client       func(...psql.PreloadOption) psql.Preloader
	Organization func(...psql.PreloadOption) psql.Preloader
	ReviewerUser func(...psql.PreloadOption) psql.Preloader
	Water        func(...psql.PreloadOption) psql.Preloader
}

func buildPublicreportReportPreloader() publicreportReportPreloader {
	return publicreportReportPreloader{
		Compliance: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*PublicreportCompliance, PublicreportComplianceSlice](psql.PreloadRel{
				Name: "Compliance",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          PublicreportCompliances,
						FromColumns: []string{"id"},
						ToColumns:   []string{"report_id"},
					},
				},
			}, PublicreportCompliances.Columns.Names(), opts...)
		},
		Nuisance: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*PublicreportNuisance, PublicreportNuisanceSlice](psql.PreloadRel{
				Name: "Nuisance",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          PublicreportNuisances,
						FromColumns: []string{"id"},
						ToColumns:   []string{"report_id"},
					},
				},
			}, PublicreportNuisances.Columns.Names(), opts...)
		},
		Address: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*Address, AddressSlice](psql.PreloadRel{
				Name: "Address",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          Addresses,
						FromColumns: []string{"address_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, Addresses.Columns.Names(), opts...)
		},
		Client: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*PublicreportClient, PublicreportClientSlice](psql.PreloadRel{
				Name: "Client",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          PublicreportClients,
						FromColumns: []string{"client_uuid"},
						ToColumns:   []string{"uuid"},
					},
				},
			}, PublicreportClients.Columns.Names(), opts...)
		},
		Organization: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*Organization, OrganizationSlice](psql.PreloadRel{
				Name: "Organization",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          Organizations,
						FromColumns: []string{"organization_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, Organizations.Columns.Names(), opts...)
		},
		ReviewerUser: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*User, UserSlice](psql.PreloadRel{
				Name: "ReviewerUser",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          Users,
						FromColumns: []string{"reviewer_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, Users.Columns.Names(), opts...)
		},
		Water: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*PublicreportWater, PublicreportWaterSlice](psql.PreloadRel{
				Name: "Water",
				Sides: []psql.PreloadSide{
					{
						From:        PublicreportReports,
						To:          PublicreportWaters,
						FromColumns: []string{"id"},
						ToColumns:   []string{"report_id"},
					},
				},
			}, PublicreportWaters.Columns.Names(), opts...)
		},
	}
}

type publicreportReportThenLoader[Q orm.Loadable] struct {
	TextJobs                   func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	SourceReportCommunications func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Compliance                 func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	NotifyEmails               func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	NotifyPhones               func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Nuisance                   func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Address                    func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Client                     func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Organization               func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	ReviewerUser               func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Images                     func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	ReportLogs                 func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Water                      func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	ReportTexts                func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	Signals                    func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
}

func buildPublicreportReportThenLoader[Q orm.Loadable]() publicreportReportThenLoader[Q] {
	type TextJobsLoadInterface interface {
		LoadTextJobs(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SourceReportCommunicationsLoadInterface interface {
		LoadSourceReportCommunications(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ComplianceLoadInterface interface {
		LoadCompliance(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type NotifyEmailsLoadInterface interface {
		LoadNotifyEmails(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type NotifyPhonesLoadInterface interface {
		LoadNotifyPhones(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type NuisanceLoadInterface interface {
		LoadNuisance(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type AddressLoadInterface interface {
		LoadAddress(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ClientLoadInterface interface {
		LoadClient(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type OrganizationLoadInterface interface {
		LoadOrganization(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ReviewerUserLoadInterface interface {
		LoadReviewerUser(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ImagesLoadInterface interface {
		LoadImages(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ReportLogsLoadInterface interface {
		LoadReportLogs(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type WaterLoadInterface interface {
		LoadWater(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ReportTextsLoadInterface interface {
		LoadReportTexts(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SignalsLoadInterface interface {
		LoadSignals(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}

	return publicreportReportThenLoader[Q]{
		TextJobs: thenLoadBuilder[Q](
			"TextJobs",
			func(ctx context.Context, exec bob.Executor, retrieved TextJobsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadTextJobs(ctx, exec, mods...)
			},
		),
		SourceReportCommunications: thenLoadBuilder[Q](
			"SourceReportCommunications",
			func(ctx context.Context, exec bob.Executor, retrieved SourceReportCommunicationsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSourceReportCommunications(ctx, exec, mods...)
			},
		),
		Compliance: thenLoadBuilder[Q](
			"Compliance",
			func(ctx context.Context, exec bob.Executor, retrieved ComplianceLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadCompliance(ctx, exec, mods...)
			},
		),
		NotifyEmails: thenLoadBuilder[Q](
			"NotifyEmails",
			func(ctx context.Context, exec bob.Executor, retrieved NotifyEmailsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadNotifyEmails(ctx, exec, mods...)
			},
		),
		NotifyPhones: thenLoadBuilder[Q](
			"NotifyPhones",
			func(ctx context.Context, exec bob.Executor, retrieved NotifyPhonesLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadNotifyPhones(ctx, exec, mods...)
			},
		),
		Nuisance: thenLoadBuilder[Q](
			"Nuisance",
			func(ctx context.Context, exec bob.Executor, retrieved NuisanceLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadNuisance(ctx, exec, mods...)
			},
		),
		Address: thenLoadBuilder[Q](
			"Address",
			func(ctx context.Context, exec bob.Executor, retrieved AddressLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadAddress(ctx, exec, mods...)
			},
		),
		Client: thenLoadBuilder[Q](
			"Client",
			func(ctx context.Context, exec bob.Executor, retrieved ClientLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadClient(ctx, exec, mods...)
			},
		),
		Organization: thenLoadBuilder[Q](
			"Organization",
			func(ctx context.Context, exec bob.Executor, retrieved OrganizationLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadOrganization(ctx, exec, mods...)
			},
		),
		ReviewerUser: thenLoadBuilder[Q](
			"ReviewerUser",
			func(ctx context.Context, exec bob.Executor, retrieved ReviewerUserLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadReviewerUser(ctx, exec, mods...)
			},
		),
		Images: thenLoadBuilder[Q](
			"Images",
			func(ctx context.Context, exec bob.Executor, retrieved ImagesLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadImages(ctx, exec, mods...)
			},
		),
		ReportLogs: thenLoadBuilder[Q](
			"ReportLogs",
			func(ctx context.Context, exec bob.Executor, retrieved ReportLogsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadReportLogs(ctx, exec, mods...)
			},
		),
		Water: thenLoadBuilder[Q](
			"Water",
			func(ctx context.Context, exec bob.Executor, retrieved WaterLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadWater(ctx, exec, mods...)
			},
		),
		ReportTexts: thenLoadBuilder[Q](
			"ReportTexts",
			func(ctx context.Context, exec bob.Executor, retrieved ReportTextsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadReportTexts(ctx, exec, mods...)
			},
		),
		Signals: thenLoadBuilder[Q](
			"Signals",
			func(ctx context.Context, exec bob.Executor, retrieved SignalsLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSignals(ctx, exec, mods...)
			},
		),
	}
}

// LoadTextJobs loads the publicreportReport's TextJobs into the .R struct
func (o *PublicreportReport) LoadTextJobs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.TextJobs = nil

	related, err := o.TextJobs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.TextJobs = related
	return nil
}

// LoadTextJobs loads the publicreportReport's TextJobs into the .R struct
func (os PublicreportReportSlice) LoadTextJobs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	commsTextJobs, err := os.TextJobs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.TextJobs = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range commsTextJobs {

			if !rel.ReportID.IsValue() {
				continue
			}
			if !(rel.ReportID.IsValue() && o.ID == rel.ReportID.MustGet()) {
				continue
			}

			rel.R.Report = o

			o.R.TextJobs = append(o.R.TextJobs, rel)
		}
	}

	return nil
}

// LoadSourceReportCommunications loads the publicreportReport's SourceReportCommunications into the .R struct
func (o *PublicreportReport) LoadSourceReportCommunications(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.SourceReportCommunications = nil

	related, err := o.SourceReportCommunications(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.SourceReportReport = o
	}

	o.R.SourceReportCommunications = related
	return nil
}

// LoadSourceReportCommunications loads the publicreportReport's SourceReportCommunications into the .R struct
func (os PublicreportReportSlice) LoadSourceReportCommunications(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	communications, err := os.SourceReportCommunications(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.SourceReportCommunications = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range communications {

			if !rel.SourceReportID.IsValue() {
				continue
			}
			if !(rel.SourceReportID.IsValue() && o.ID == rel.SourceReportID.MustGet()) {
				continue
			}

			rel.R.SourceReportReport = o

			o.R.SourceReportCommunications = append(o.R.SourceReportCommunications, rel)
		}
	}

	return nil
}

// LoadCompliance loads the publicreportReport's Compliance into the .R struct
func (o *PublicreportReport) LoadCompliance(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Compliance = nil

	related, err := o.Compliance(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Report = o

	o.R.Compliance = related
	return nil
}

// LoadCompliance loads the publicreportReport's Compliance into the .R struct
func (os PublicreportReportSlice) LoadCompliance(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportCompliances, err := os.Compliance(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportCompliances {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.Compliance = rel
			break
		}
	}

	return nil
}

// LoadNotifyEmails loads the publicreportReport's NotifyEmails into the .R struct
func (o *PublicreportReport) LoadNotifyEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.NotifyEmails = nil

	related, err := o.NotifyEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.NotifyEmails = related
	return nil
}

// LoadNotifyEmails loads the publicreportReport's NotifyEmails into the .R struct
func (os PublicreportReportSlice) LoadNotifyEmails(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNotifyEmails, err := os.NotifyEmails(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.NotifyEmails = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNotifyEmails {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.NotifyEmails = append(o.R.NotifyEmails, rel)
		}
	}

	return nil
}

// LoadNotifyPhones loads the publicreportReport's NotifyPhones into the .R struct
func (o *PublicreportReport) LoadNotifyPhones(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.NotifyPhones = nil

	related, err := o.NotifyPhones(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.NotifyPhones = related
	return nil
}

// LoadNotifyPhones loads the publicreportReport's NotifyPhones into the .R struct
func (os PublicreportReportSlice) LoadNotifyPhones(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNotifyPhones, err := os.NotifyPhones(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.NotifyPhones = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNotifyPhones {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.NotifyPhones = append(o.R.NotifyPhones, rel)
		}
	}

	return nil
}

// LoadNuisance loads the publicreportReport's Nuisance into the .R struct
func (o *PublicreportReport) LoadNuisance(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Nuisance = nil

	related, err := o.Nuisance(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Report = o

	o.R.Nuisance = related
	return nil
}

// LoadNuisance loads the publicreportReport's Nuisance into the .R struct
func (os PublicreportReportSlice) LoadNuisance(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportNuisances, err := os.Nuisance(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportNuisances {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.Nuisance = rel
			break
		}
	}

	return nil
}

// LoadAddress loads the publicreportReport's Address into the .R struct
func (o *PublicreportReport) LoadAddress(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Address = nil

	related, err := o.Address(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Reports = PublicreportReportSlice{o}

	o.R.Address = related
	return nil
}

// LoadAddress loads the publicreportReport's Address into the .R struct
func (os PublicreportReportSlice) LoadAddress(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	addresses, err := os.Address(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range addresses {
			if !o.AddressID.IsValue() {
				continue
			}

			if !(o.AddressID.IsValue() && o.AddressID.MustGet() == rel.ID) {
				continue
			}

			rel.R.Reports = append(rel.R.Reports, o)

			o.R.Address = rel
			break
		}
	}

	return nil
}

// LoadClient loads the publicreportReport's Client into the .R struct
func (o *PublicreportReport) LoadClient(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Client = nil

	related, err := o.Client(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Reports = PublicreportReportSlice{o}

	o.R.Client = related
	return nil
}

// LoadClient loads the publicreportReport's Client into the .R struct
func (os PublicreportReportSlice) LoadClient(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportClients, err := os.Client(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportClients {
			if !o.ClientUUID.IsValue() {
				continue
			}

			if !(o.ClientUUID.IsValue() && o.ClientUUID.MustGet() == rel.UUID) {
				continue
			}

			rel.R.Reports = append(rel.R.Reports, o)

			o.R.Client = rel
			break
		}
	}

	return nil
}

// LoadOrganization loads the publicreportReport's Organization into the .R struct
func (o *PublicreportReport) LoadOrganization(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Organization = nil

	related, err := o.Organization(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Reports = PublicreportReportSlice{o}

	o.R.Organization = related
	return nil
}

// LoadOrganization loads the publicreportReport's Organization into the .R struct
func (os PublicreportReportSlice) LoadOrganization(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	organizations, err := os.Organization(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range organizations {

			if !(o.OrganizationID == rel.ID) {
				continue
			}

			rel.R.Reports = append(rel.R.Reports, o)

			o.R.Organization = rel
			break
		}
	}

	return nil
}

// LoadReviewerUser loads the publicreportReport's ReviewerUser into the .R struct
func (o *PublicreportReport) LoadReviewerUser(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.ReviewerUser = nil

	related, err := o.ReviewerUser(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.ReviewerReports = PublicreportReportSlice{o}

	o.R.ReviewerUser = related
	return nil
}

// LoadReviewerUser loads the publicreportReport's ReviewerUser into the .R struct
func (os PublicreportReportSlice) LoadReviewerUser(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	users, err := os.ReviewerUser(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range users {
			if !o.ReviewerID.IsValue() {
				continue
			}

			if !(o.ReviewerID.IsValue() && o.ReviewerID.MustGet() == rel.ID) {
				continue
			}

			rel.R.ReviewerReports = append(rel.R.ReviewerReports, o)

			o.R.ReviewerUser = rel
			break
		}
	}

	return nil
}

// LoadImages loads the publicreportReport's Images into the .R struct
func (o *PublicreportReport) LoadImages(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Images = nil

	related, err := o.Images(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Reports = PublicreportReportSlice{o}
	}

	o.R.Images = related
	return nil
}

// LoadImages loads the publicreportReport's Images into the .R struct
func (os PublicreportReportSlice) LoadImages(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	// since we are changing the columns, we need to check if the original columns were set or add the defaults
	sq := dialect.SelectQuery{}
	for _, mod := range mods {
		mod.Apply(&sq)
	}

	if len(sq.SelectList.Columns) == 0 {
		mods = append(mods, sm.Columns(PublicreportImages.Columns))
	}

	q := os.Images(append(
		mods,
		sm.Columns(PublicreportReportImages.Columns.ReportID.As("related_publicreport.report.ID")),
	)...)

	IDSlice := []int32{}

	mapper := scan.Mod(scan.StructMapper[*PublicreportImage](), func(ctx context.Context, cols []string) (scan.BeforeFunc, func(any, any) error) {
		return func(row *scan.Row) (any, error) {
				IDSlice = append(IDSlice, *new(int32))
				row.ScheduleScanByName("related_publicreport.report.ID", &IDSlice[len(IDSlice)-1])

				return nil, nil
			},
			func(any, any) error {
				return nil
			}
	})

	publicreportImages, err := bob.Allx[bob.SliceTransformer[*PublicreportImage, PublicreportImageSlice]](ctx, exec, q, mapper)
	if err != nil {
		return err
	}

	for _, o := range os {
		o.R.Images = nil
	}

	for _, o := range os {
		for i, rel := range publicreportImages {
			if !(o.ID == IDSlice[i]) {
				continue
			}

			rel.R.Reports = append(rel.R.Reports, o)

			o.R.Images = append(o.R.Images, rel)
		}
	}

	return nil
}

// LoadReportLogs loads the publicreportReport's ReportLogs into the .R struct
func (o *PublicreportReport) LoadReportLogs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.ReportLogs = nil

	related, err := o.ReportLogs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.ReportLogs = related
	return nil
}

// LoadReportLogs loads the publicreportReport's ReportLogs into the .R struct
func (os PublicreportReportSlice) LoadReportLogs(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportReportLogs, err := os.ReportLogs(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.ReportLogs = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportReportLogs {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.ReportLogs = append(o.R.ReportLogs, rel)
		}
	}

	return nil
}

// LoadWater loads the publicreportReport's Water into the .R struct
func (o *PublicreportReport) LoadWater(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Water = nil

	related, err := o.Water(mods...).One(ctx, exec)
	if err != nil {
		return err
	}

	related.R.Report = o

	o.R.Water = related
	return nil
}

// LoadWater loads the publicreportReport's Water into the .R struct
func (os PublicreportReportSlice) LoadWater(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	publicreportWaters, err := os.Water(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range publicreportWaters {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.Water = rel
			break
		}
	}

	return nil
}

// LoadReportTexts loads the publicreportReport's ReportTexts into the .R struct
func (o *PublicreportReport) LoadReportTexts(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.ReportTexts = nil

	related, err := o.ReportTexts(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.ReportTexts = related
	return nil
}

// LoadReportTexts loads the publicreportReport's ReportTexts into the .R struct
func (os PublicreportReportSlice) LoadReportTexts(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	reportTexts, err := os.ReportTexts(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.ReportTexts = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range reportTexts {

			if !(o.ID == rel.ReportID) {
				continue
			}

			rel.R.Report = o

			o.R.ReportTexts = append(o.R.ReportTexts, rel)
		}
	}

	return nil
}

// LoadSignals loads the publicreportReport's Signals into the .R struct
func (o *PublicreportReport) LoadSignals(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if o == nil {
		return nil
	}

	// Reset the relationship
	o.R.Signals = nil

	related, err := o.Signals(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, rel := range related {
		rel.R.Report = o
	}

	o.R.Signals = related
	return nil
}

// LoadSignals loads the publicreportReport's Signals into the .R struct
func (os PublicreportReportSlice) LoadSignals(ctx context.Context, exec bob.Executor, mods ...bob.Mod[*dialect.SelectQuery]) error {
	if len(os) == 0 {
		return nil
	}

	signals, err := os.Signals(mods...).All(ctx, exec)
	if err != nil {
		return err
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		o.R.Signals = nil
	}

	for _, o := range os {
		if o == nil {
			continue
		}

		for _, rel := range signals {

			if !rel.ReportID.IsValue() {
				continue
			}
			if !(rel.ReportID.IsValue() && o.ID == rel.ReportID.MustGet()) {
				continue
			}

			rel.R.Report = o

			o.R.Signals = append(o.R.Signals, rel)
		}
	}

	return nil
}