nidus-sync/db/models/communication.bob.go

// 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"
	"github.com/aarondl/opt/null"
	"github.com/aarondl/opt/omit"
	"github.com/aarondl/opt/omitnull"
)

// Communication is an object representing the database table.
type Communication struct {
	Closed             null.Val[time.Time] `db:"closed" `
	ClosedBy           null.Val[int32]     `db:"closed_by" `
	Created            time.Time           `db:"created" `
	ID                 int32               `db:"id,pk" `
	Invalidated        null.Val[time.Time] `db:"invalidated" `
	InvalidatedBy      null.Val[int32]     `db:"invalidated_by" `
	Opened             null.Val[time.Time] `db:"opened" `
	OpenedBy           null.Val[int32]     `db:"opened_by" `
	ResponseEmailLogID null.Val[int32]     `db:"response_email_log_id" `
	ResponseTextLogID  null.Val[int32]     `db:"response_text_log_id" `
	SetPending         null.Val[time.Time] `db:"set_pending" `
	SetPendingBy       null.Val[int32]     `db:"set_pending_by" `
	SourceEmailLogID   null.Val[int32]     `db:"source_email_log_id" `
	SourceReportID     null.Val[int32]     `db:"source_report_id" `
	SourceTextLogID    null.Val[int32]     `db:"source_text_log_id" `

	R communicationR `db:"-" `
}

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

// Communications contains methods to work with the communication table
var Communications = psql.NewTablex[*Communication, CommunicationSlice, *CommunicationSetter]("", "communication", buildCommunicationColumns("communication"))

// CommunicationsQuery is a query on the communication table
type CommunicationsQuery = *psql.ViewQuery[*Communication, CommunicationSlice]

// communicationR is where relationships are stored.
type communicationR struct {
	ClosedByUser             *User               // communication.communication_closed_by_fkey
	InvalidatedByUser        *User               // communication.communication_invalidated_by_fkey
	OpenedByUser             *User               // communication.communication_opened_by_fkey
	ResponseEmailLogEmailLog *CommsEmailLog      // communication.communication_response_email_log_id_fkey
	ResponseTextLogTextLog   *CommsTextLog       // communication.communication_response_text_log_id_fkey
	SetPendingByUser         *User               // communication.communication_set_pending_by_fkey
	SourceEmailLogEmailLog   *CommsEmailLog      // communication.communication_source_email_log_id_fkey
	SourceReportReport       *PublicreportReport // communication.communication_source_report_id_fkey
	SourceTextLogTextLog     *CommsTextLog       // communication.communication_source_text_log_id_fkey
}

func buildCommunicationColumns(alias string) communicationColumns {
	return communicationColumns{
		ColumnsExpr: expr.NewColumnsExpr(
			"closed", "closed_by", "created", "id", "invalidated", "invalidated_by", "opened", "opened_by", "response_email_log_id", "response_text_log_id", "set_pending", "set_pending_by", "source_email_log_id", "source_report_id", "source_text_log_id",
		).WithParent("communication"),
		tableAlias:         alias,
		Closed:             psql.Quote(alias, "closed"),
		ClosedBy:           psql.Quote(alias, "closed_by"),
		Created:            psql.Quote(alias, "created"),
		ID:                 psql.Quote(alias, "id"),
		Invalidated:        psql.Quote(alias, "invalidated"),
		InvalidatedBy:      psql.Quote(alias, "invalidated_by"),
		Opened:             psql.Quote(alias, "opened"),
		OpenedBy:           psql.Quote(alias, "opened_by"),
		ResponseEmailLogID: psql.Quote(alias, "response_email_log_id"),
		ResponseTextLogID:  psql.Quote(alias, "response_text_log_id"),
		SetPending:         psql.Quote(alias, "set_pending"),
		SetPendingBy:       psql.Quote(alias, "set_pending_by"),
		SourceEmailLogID:   psql.Quote(alias, "source_email_log_id"),
		SourceReportID:     psql.Quote(alias, "source_report_id"),
		SourceTextLogID:    psql.Quote(alias, "source_text_log_id"),
	}
}

type communicationColumns struct {
	expr.ColumnsExpr
	tableAlias         string
	Closed             psql.Expression
	ClosedBy           psql.Expression
	Created            psql.Expression
	ID                 psql.Expression
	Invalidated        psql.Expression
	InvalidatedBy      psql.Expression
	Opened             psql.Expression
	OpenedBy           psql.Expression
	ResponseEmailLogID psql.Expression
	ResponseTextLogID  psql.Expression
	SetPending         psql.Expression
	SetPendingBy       psql.Expression
	SourceEmailLogID   psql.Expression
	SourceReportID     psql.Expression
	SourceTextLogID    psql.Expression
}

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

func (communicationColumns) AliasedAs(alias string) communicationColumns {
	return buildCommunicationColumns(alias)
}

// CommunicationSetter is used for insert/upsert/update operations
// All values are optional, and do not have to be set
// Generated columns are not included
type CommunicationSetter struct {
	Closed             omitnull.Val[time.Time] `db:"closed" `
	ClosedBy           omitnull.Val[int32]     `db:"closed_by" `
	Created            omit.Val[time.Time]     `db:"created" `
	ID                 omit.Val[int32]         `db:"id,pk" `
	Invalidated        omitnull.Val[time.Time] `db:"invalidated" `
	InvalidatedBy      omitnull.Val[int32]     `db:"invalidated_by" `
	Opened             omitnull.Val[time.Time] `db:"opened" `
	OpenedBy           omitnull.Val[int32]     `db:"opened_by" `
	ResponseEmailLogID omitnull.Val[int32]     `db:"response_email_log_id" `
	ResponseTextLogID  omitnull.Val[int32]     `db:"response_text_log_id" `
	SetPending         omitnull.Val[time.Time] `db:"set_pending" `
	SetPendingBy       omitnull.Val[int32]     `db:"set_pending_by" `
	SourceEmailLogID   omitnull.Val[int32]     `db:"source_email_log_id" `
	SourceReportID     omitnull.Val[int32]     `db:"source_report_id" `
	SourceTextLogID    omitnull.Val[int32]     `db:"source_text_log_id" `
}

func (s CommunicationSetter) SetColumns() []string {
	vals := make([]string, 0, 15)
	if !s.Closed.IsUnset() {
		vals = append(vals, "closed")
	}
	if !s.ClosedBy.IsUnset() {
		vals = append(vals, "closed_by")
	}
	if s.Created.IsValue() {
		vals = append(vals, "created")
	}
	if s.ID.IsValue() {
		vals = append(vals, "id")
	}
	if !s.Invalidated.IsUnset() {
		vals = append(vals, "invalidated")
	}
	if !s.InvalidatedBy.IsUnset() {
		vals = append(vals, "invalidated_by")
	}
	if !s.Opened.IsUnset() {
		vals = append(vals, "opened")
	}
	if !s.OpenedBy.IsUnset() {
		vals = append(vals, "opened_by")
	}
	if !s.ResponseEmailLogID.IsUnset() {
		vals = append(vals, "response_email_log_id")
	}
	if !s.ResponseTextLogID.IsUnset() {
		vals = append(vals, "response_text_log_id")
	}
	if !s.SetPending.IsUnset() {
		vals = append(vals, "set_pending")
	}
	if !s.SetPendingBy.IsUnset() {
		vals = append(vals, "set_pending_by")
	}
	if !s.SourceEmailLogID.IsUnset() {
		vals = append(vals, "source_email_log_id")
	}
	if !s.SourceReportID.IsUnset() {
		vals = append(vals, "source_report_id")
	}
	if !s.SourceTextLogID.IsUnset() {
		vals = append(vals, "source_text_log_id")
	}
	return vals
}

func (s CommunicationSetter) Overwrite(t *Communication) {
	if !s.Closed.IsUnset() {
		t.Closed = s.Closed.MustGetNull()
	}
	if !s.ClosedBy.IsUnset() {
		t.ClosedBy = s.ClosedBy.MustGetNull()
	}
	if s.Created.IsValue() {
		t.Created = s.Created.MustGet()
	}
	if s.ID.IsValue() {
		t.ID = s.ID.MustGet()
	}
	if !s.Invalidated.IsUnset() {
		t.Invalidated = s.Invalidated.MustGetNull()
	}
	if !s.InvalidatedBy.IsUnset() {
		t.InvalidatedBy = s.InvalidatedBy.MustGetNull()
	}
	if !s.Opened.IsUnset() {
		t.Opened = s.Opened.MustGetNull()
	}
	if !s.OpenedBy.IsUnset() {
		t.OpenedBy = s.OpenedBy.MustGetNull()
	}
	if !s.ResponseEmailLogID.IsUnset() {
		t.ResponseEmailLogID = s.ResponseEmailLogID.MustGetNull()
	}
	if !s.ResponseTextLogID.IsUnset() {
		t.ResponseTextLogID = s.ResponseTextLogID.MustGetNull()
	}
	if !s.SetPending.IsUnset() {
		t.SetPending = s.SetPending.MustGetNull()
	}
	if !s.SetPendingBy.IsUnset() {
		t.SetPendingBy = s.SetPendingBy.MustGetNull()
	}
	if !s.SourceEmailLogID.IsUnset() {
		t.SourceEmailLogID = s.SourceEmailLogID.MustGetNull()
	}
	if !s.SourceReportID.IsUnset() {
		t.SourceReportID = s.SourceReportID.MustGetNull()
	}
	if !s.SourceTextLogID.IsUnset() {
		t.SourceTextLogID = s.SourceTextLogID.MustGetNull()
	}
}

func (s *CommunicationSetter) Apply(q *dialect.InsertQuery) {
	q.AppendHooks(func(ctx context.Context, exec bob.Executor) (context.Context, error) {
		return Communications.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, 15)
		if !s.Closed.IsUnset() {
			vals[0] = psql.Arg(s.Closed.MustGetNull())
		} else {
			vals[0] = psql.Raw("DEFAULT")
		}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	return exprs
}

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

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

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

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

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

	return err
}

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

func (o *Communication) pkEQ() dialect.Expression {
	return psql.Quote("communication", "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 Communication
func (o *Communication) Update(ctx context.Context, exec bob.Executor, s *CommunicationSetter) error {
	v, err := Communications.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 Communication record with an executor
func (o *Communication) Delete(ctx context.Context, exec bob.Executor) error {
	_, err := Communications.Delete(dm.Where(o.pkEQ())).Exec(ctx, exec)
	return err
}

// Reload refreshes the Communication using the executor
func (o *Communication) Reload(ctx context.Context, exec bob.Executor) error {
	o2, err := Communications.Query(
		sm.Where(Communications.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 CommunicationSlice is retrieved from the database
func (o CommunicationSlice) AfterQueryHook(ctx context.Context, exec bob.Executor, queryType bob.QueryType) error {
	var err error

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

	return err
}

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

	return psql.Quote("communication", "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 CommunicationSlice) copyMatchingRows(from ...*Communication) {
	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 CommunicationSlice) 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 Communications.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 *Communication:
				o.copyMatchingRows(retrieved)
			case []*Communication:
				o.copyMatchingRows(retrieved...)
			case CommunicationSlice:
				o.copyMatchingRows(retrieved...)
			default:
				// If the retrieved value is not a Communication or a slice of Communication
				// then run the AfterUpdateHooks on the slice
				_, err = Communications.AfterUpdateHooks.RunHooks(ctx, exec, o)
			}

			return err
		}))

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

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

			return err
		}))

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

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

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

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

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

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

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

	o.copyMatchingRows(o2...)

	return nil
}

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

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

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

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

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

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

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

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

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

// ResponseEmailLogEmailLog starts a query for related objects on comms.email_log
func (o *Communication) ResponseEmailLogEmailLog(mods ...bob.Mod[*dialect.SelectQuery]) CommsEmailLogsQuery {
	return CommsEmailLogs.Query(append(mods,
		sm.Where(CommsEmailLogs.Columns.ID.EQ(psql.Arg(o.ResponseEmailLogID))),
	)...)
}

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

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

// ResponseTextLogTextLog starts a query for related objects on comms.text_log
func (o *Communication) ResponseTextLogTextLog(mods ...bob.Mod[*dialect.SelectQuery]) CommsTextLogsQuery {
	return CommsTextLogs.Query(append(mods,
		sm.Where(CommsTextLogs.Columns.ID.EQ(psql.Arg(o.ResponseTextLogID))),
	)...)
}

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

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

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

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

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

// SourceEmailLogEmailLog starts a query for related objects on comms.email_log
func (o *Communication) SourceEmailLogEmailLog(mods ...bob.Mod[*dialect.SelectQuery]) CommsEmailLogsQuery {
	return CommsEmailLogs.Query(append(mods,
		sm.Where(CommsEmailLogs.Columns.ID.EQ(psql.Arg(o.SourceEmailLogID))),
	)...)
}

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

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

// SourceReportReport starts a query for related objects on publicreport.report
func (o *Communication) SourceReportReport(mods ...bob.Mod[*dialect.SelectQuery]) PublicreportReportsQuery {
	return PublicreportReports.Query(append(mods,
		sm.Where(PublicreportReports.Columns.ID.EQ(psql.Arg(o.SourceReportID))),
	)...)
}

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

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

// SourceTextLogTextLog starts a query for related objects on comms.text_log
func (o *Communication) SourceTextLogTextLog(mods ...bob.Mod[*dialect.SelectQuery]) CommsTextLogsQuery {
	return CommsTextLogs.Query(append(mods,
		sm.Where(CommsTextLogs.Columns.ID.EQ(psql.Arg(o.SourceTextLogID))),
	)...)
}

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

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

func attachCommunicationClosedByUser0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, user1 *User) (*Communication, error) {
	setter := &CommunicationSetter{
		ClosedBy: omitnull.From(user1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertClosedByUser(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 = attachCommunicationClosedByUser0(ctx, exec, 1, communication0, user1)
	if err != nil {
		return err
	}

	communication0.R.ClosedByUser = user1

	user1.R.ClosedByCommunications = append(user1.R.ClosedByCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachClosedByUser(ctx context.Context, exec bob.Executor, user1 *User) error {
	var err error

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

	communication0.R.ClosedByUser = user1

	user1.R.ClosedByCommunications = append(user1.R.ClosedByCommunications, communication0)

	return nil
}

func attachCommunicationInvalidatedByUser0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, user1 *User) (*Communication, error) {
	setter := &CommunicationSetter{
		InvalidatedBy: omitnull.From(user1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertInvalidatedByUser(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 = attachCommunicationInvalidatedByUser0(ctx, exec, 1, communication0, user1)
	if err != nil {
		return err
	}

	communication0.R.InvalidatedByUser = user1

	user1.R.InvalidatedByCommunications = append(user1.R.InvalidatedByCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachInvalidatedByUser(ctx context.Context, exec bob.Executor, user1 *User) error {
	var err error

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

	communication0.R.InvalidatedByUser = user1

	user1.R.InvalidatedByCommunications = append(user1.R.InvalidatedByCommunications, communication0)

	return nil
}

func attachCommunicationOpenedByUser0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, user1 *User) (*Communication, error) {
	setter := &CommunicationSetter{
		OpenedBy: omitnull.From(user1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertOpenedByUser(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 = attachCommunicationOpenedByUser0(ctx, exec, 1, communication0, user1)
	if err != nil {
		return err
	}

	communication0.R.OpenedByUser = user1

	user1.R.OpenedByCommunications = append(user1.R.OpenedByCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachOpenedByUser(ctx context.Context, exec bob.Executor, user1 *User) error {
	var err error

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

	communication0.R.OpenedByUser = user1

	user1.R.OpenedByCommunications = append(user1.R.OpenedByCommunications, communication0)

	return nil
}

func attachCommunicationResponseEmailLogEmailLog0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, commsEmailLog1 *CommsEmailLog) (*Communication, error) {
	setter := &CommunicationSetter{
		ResponseEmailLogID: omitnull.From(commsEmailLog1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertResponseEmailLogEmailLog(ctx context.Context, exec bob.Executor, related *CommsEmailLogSetter) error {
	var err error

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

	_, err = attachCommunicationResponseEmailLogEmailLog0(ctx, exec, 1, communication0, commsEmailLog1)
	if err != nil {
		return err
	}

	communication0.R.ResponseEmailLogEmailLog = commsEmailLog1

	commsEmailLog1.R.ResponseEmailLogCommunications = append(commsEmailLog1.R.ResponseEmailLogCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachResponseEmailLogEmailLog(ctx context.Context, exec bob.Executor, commsEmailLog1 *CommsEmailLog) error {
	var err error

	_, err = attachCommunicationResponseEmailLogEmailLog0(ctx, exec, 1, communication0, commsEmailLog1)
	if err != nil {
		return err
	}

	communication0.R.ResponseEmailLogEmailLog = commsEmailLog1

	commsEmailLog1.R.ResponseEmailLogCommunications = append(commsEmailLog1.R.ResponseEmailLogCommunications, communication0)

	return nil
}

func attachCommunicationResponseTextLogTextLog0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, commsTextLog1 *CommsTextLog) (*Communication, error) {
	setter := &CommunicationSetter{
		ResponseTextLogID: omitnull.From(commsTextLog1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertResponseTextLogTextLog(ctx context.Context, exec bob.Executor, related *CommsTextLogSetter) error {
	var err error

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

	_, err = attachCommunicationResponseTextLogTextLog0(ctx, exec, 1, communication0, commsTextLog1)
	if err != nil {
		return err
	}

	communication0.R.ResponseTextLogTextLog = commsTextLog1

	commsTextLog1.R.ResponseTextLogCommunications = append(commsTextLog1.R.ResponseTextLogCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachResponseTextLogTextLog(ctx context.Context, exec bob.Executor, commsTextLog1 *CommsTextLog) error {
	var err error

	_, err = attachCommunicationResponseTextLogTextLog0(ctx, exec, 1, communication0, commsTextLog1)
	if err != nil {
		return err
	}

	communication0.R.ResponseTextLogTextLog = commsTextLog1

	commsTextLog1.R.ResponseTextLogCommunications = append(commsTextLog1.R.ResponseTextLogCommunications, communication0)

	return nil
}

func attachCommunicationSetPendingByUser0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, user1 *User) (*Communication, error) {
	setter := &CommunicationSetter{
		SetPendingBy: omitnull.From(user1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertSetPendingByUser(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 = attachCommunicationSetPendingByUser0(ctx, exec, 1, communication0, user1)
	if err != nil {
		return err
	}

	communication0.R.SetPendingByUser = user1

	user1.R.SetPendingByCommunications = append(user1.R.SetPendingByCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachSetPendingByUser(ctx context.Context, exec bob.Executor, user1 *User) error {
	var err error

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

	communication0.R.SetPendingByUser = user1

	user1.R.SetPendingByCommunications = append(user1.R.SetPendingByCommunications, communication0)

	return nil
}

func attachCommunicationSourceEmailLogEmailLog0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, commsEmailLog1 *CommsEmailLog) (*Communication, error) {
	setter := &CommunicationSetter{
		SourceEmailLogID: omitnull.From(commsEmailLog1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertSourceEmailLogEmailLog(ctx context.Context, exec bob.Executor, related *CommsEmailLogSetter) error {
	var err error

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

	_, err = attachCommunicationSourceEmailLogEmailLog0(ctx, exec, 1, communication0, commsEmailLog1)
	if err != nil {
		return err
	}

	communication0.R.SourceEmailLogEmailLog = commsEmailLog1

	commsEmailLog1.R.SourceEmailLogCommunications = append(commsEmailLog1.R.SourceEmailLogCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachSourceEmailLogEmailLog(ctx context.Context, exec bob.Executor, commsEmailLog1 *CommsEmailLog) error {
	var err error

	_, err = attachCommunicationSourceEmailLogEmailLog0(ctx, exec, 1, communication0, commsEmailLog1)
	if err != nil {
		return err
	}

	communication0.R.SourceEmailLogEmailLog = commsEmailLog1

	commsEmailLog1.R.SourceEmailLogCommunications = append(commsEmailLog1.R.SourceEmailLogCommunications, communication0)

	return nil
}

func attachCommunicationSourceReportReport0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, publicreportReport1 *PublicreportReport) (*Communication, error) {
	setter := &CommunicationSetter{
		SourceReportID: omitnull.From(publicreportReport1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertSourceReportReport(ctx context.Context, exec bob.Executor, related *PublicreportReportSetter) error {
	var err error

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

	_, err = attachCommunicationSourceReportReport0(ctx, exec, 1, communication0, publicreportReport1)
	if err != nil {
		return err
	}

	communication0.R.SourceReportReport = publicreportReport1

	publicreportReport1.R.SourceReportCommunications = append(publicreportReport1.R.SourceReportCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachSourceReportReport(ctx context.Context, exec bob.Executor, publicreportReport1 *PublicreportReport) error {
	var err error

	_, err = attachCommunicationSourceReportReport0(ctx, exec, 1, communication0, publicreportReport1)
	if err != nil {
		return err
	}

	communication0.R.SourceReportReport = publicreportReport1

	publicreportReport1.R.SourceReportCommunications = append(publicreportReport1.R.SourceReportCommunications, communication0)

	return nil
}

func attachCommunicationSourceTextLogTextLog0(ctx context.Context, exec bob.Executor, count int, communication0 *Communication, commsTextLog1 *CommsTextLog) (*Communication, error) {
	setter := &CommunicationSetter{
		SourceTextLogID: omitnull.From(commsTextLog1.ID),
	}

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

	return communication0, nil
}

func (communication0 *Communication) InsertSourceTextLogTextLog(ctx context.Context, exec bob.Executor, related *CommsTextLogSetter) error {
	var err error

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

	_, err = attachCommunicationSourceTextLogTextLog0(ctx, exec, 1, communication0, commsTextLog1)
	if err != nil {
		return err
	}

	communication0.R.SourceTextLogTextLog = commsTextLog1

	commsTextLog1.R.SourceTextLogCommunications = append(commsTextLog1.R.SourceTextLogCommunications, communication0)

	return nil
}

func (communication0 *Communication) AttachSourceTextLogTextLog(ctx context.Context, exec bob.Executor, commsTextLog1 *CommsTextLog) error {
	var err error

	_, err = attachCommunicationSourceTextLogTextLog0(ctx, exec, 1, communication0, commsTextLog1)
	if err != nil {
		return err
	}

	communication0.R.SourceTextLogTextLog = commsTextLog1

	commsTextLog1.R.SourceTextLogCommunications = append(commsTextLog1.R.SourceTextLogCommunications, communication0)

	return nil
}

type communicationWhere[Q psql.Filterable] struct {
	Closed             psql.WhereNullMod[Q, time.Time]
	ClosedBy           psql.WhereNullMod[Q, int32]
	Created            psql.WhereMod[Q, time.Time]
	ID                 psql.WhereMod[Q, int32]
	Invalidated        psql.WhereNullMod[Q, time.Time]
	InvalidatedBy      psql.WhereNullMod[Q, int32]
	Opened             psql.WhereNullMod[Q, time.Time]
	OpenedBy           psql.WhereNullMod[Q, int32]
	ResponseEmailLogID psql.WhereNullMod[Q, int32]
	ResponseTextLogID  psql.WhereNullMod[Q, int32]
	SetPending         psql.WhereNullMod[Q, time.Time]
	SetPendingBy       psql.WhereNullMod[Q, int32]
	SourceEmailLogID   psql.WhereNullMod[Q, int32]
	SourceReportID     psql.WhereNullMod[Q, int32]
	SourceTextLogID    psql.WhereNullMod[Q, int32]
}

func (communicationWhere[Q]) AliasedAs(alias string) communicationWhere[Q] {
	return buildCommunicationWhere[Q](buildCommunicationColumns(alias))
}

func buildCommunicationWhere[Q psql.Filterable](cols communicationColumns) communicationWhere[Q] {
	return communicationWhere[Q]{
		Closed:             psql.WhereNull[Q, time.Time](cols.Closed),
		ClosedBy:           psql.WhereNull[Q, int32](cols.ClosedBy),
		Created:            psql.Where[Q, time.Time](cols.Created),
		ID:                 psql.Where[Q, int32](cols.ID),
		Invalidated:        psql.WhereNull[Q, time.Time](cols.Invalidated),
		InvalidatedBy:      psql.WhereNull[Q, int32](cols.InvalidatedBy),
		Opened:             psql.WhereNull[Q, time.Time](cols.Opened),
		OpenedBy:           psql.WhereNull[Q, int32](cols.OpenedBy),
		ResponseEmailLogID: psql.WhereNull[Q, int32](cols.ResponseEmailLogID),
		ResponseTextLogID:  psql.WhereNull[Q, int32](cols.ResponseTextLogID),
		SetPending:         psql.WhereNull[Q, time.Time](cols.SetPending),
		SetPendingBy:       psql.WhereNull[Q, int32](cols.SetPendingBy),
		SourceEmailLogID:   psql.WhereNull[Q, int32](cols.SourceEmailLogID),
		SourceReportID:     psql.WhereNull[Q, int32](cols.SourceReportID),
		SourceTextLogID:    psql.WhereNull[Q, int32](cols.SourceTextLogID),
	}
}

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

	switch name {
	case "ClosedByUser":
		rel, ok := retrieved.(*User)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.ClosedByUser = rel

		if rel != nil {
			rel.R.ClosedByCommunications = CommunicationSlice{o}
		}
		return nil
	case "InvalidatedByUser":
		rel, ok := retrieved.(*User)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.InvalidatedByUser = rel

		if rel != nil {
			rel.R.InvalidatedByCommunications = CommunicationSlice{o}
		}
		return nil
	case "OpenedByUser":
		rel, ok := retrieved.(*User)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.OpenedByUser = rel

		if rel != nil {
			rel.R.OpenedByCommunications = CommunicationSlice{o}
		}
		return nil
	case "ResponseEmailLogEmailLog":
		rel, ok := retrieved.(*CommsEmailLog)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.ResponseEmailLogEmailLog = rel

		if rel != nil {
			rel.R.ResponseEmailLogCommunications = CommunicationSlice{o}
		}
		return nil
	case "ResponseTextLogTextLog":
		rel, ok := retrieved.(*CommsTextLog)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.ResponseTextLogTextLog = rel

		if rel != nil {
			rel.R.ResponseTextLogCommunications = CommunicationSlice{o}
		}
		return nil
	case "SetPendingByUser":
		rel, ok := retrieved.(*User)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.SetPendingByUser = rel

		if rel != nil {
			rel.R.SetPendingByCommunications = CommunicationSlice{o}
		}
		return nil
	case "SourceEmailLogEmailLog":
		rel, ok := retrieved.(*CommsEmailLog)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.SourceEmailLogEmailLog = rel

		if rel != nil {
			rel.R.SourceEmailLogCommunications = CommunicationSlice{o}
		}
		return nil
	case "SourceReportReport":
		rel, ok := retrieved.(*PublicreportReport)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.SourceReportReport = rel

		if rel != nil {
			rel.R.SourceReportCommunications = CommunicationSlice{o}
		}
		return nil
	case "SourceTextLogTextLog":
		rel, ok := retrieved.(*CommsTextLog)
		if !ok {
			return fmt.Errorf("communication cannot load %T as %q", retrieved, name)
		}

		o.R.SourceTextLogTextLog = rel

		if rel != nil {
			rel.R.SourceTextLogCommunications = CommunicationSlice{o}
		}
		return nil
	default:
		return fmt.Errorf("communication has no relationship %q", name)
	}
}

type communicationPreloader struct {
	ClosedByUser             func(...psql.PreloadOption) psql.Preloader
	InvalidatedByUser        func(...psql.PreloadOption) psql.Preloader
	OpenedByUser             func(...psql.PreloadOption) psql.Preloader
	ResponseEmailLogEmailLog func(...psql.PreloadOption) psql.Preloader
	ResponseTextLogTextLog   func(...psql.PreloadOption) psql.Preloader
	SetPendingByUser         func(...psql.PreloadOption) psql.Preloader
	SourceEmailLogEmailLog   func(...psql.PreloadOption) psql.Preloader
	SourceReportReport       func(...psql.PreloadOption) psql.Preloader
	SourceTextLogTextLog     func(...psql.PreloadOption) psql.Preloader
}

func buildCommunicationPreloader() communicationPreloader {
	return communicationPreloader{
		ClosedByUser: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*User, UserSlice](psql.PreloadRel{
				Name: "ClosedByUser",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          Users,
						FromColumns: []string{"closed_by"},
						ToColumns:   []string{"id"},
					},
				},
			}, Users.Columns.Names(), opts...)
		},
		InvalidatedByUser: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*User, UserSlice](psql.PreloadRel{
				Name: "InvalidatedByUser",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          Users,
						FromColumns: []string{"invalidated_by"},
						ToColumns:   []string{"id"},
					},
				},
			}, Users.Columns.Names(), opts...)
		},
		OpenedByUser: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*User, UserSlice](psql.PreloadRel{
				Name: "OpenedByUser",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          Users,
						FromColumns: []string{"opened_by"},
						ToColumns:   []string{"id"},
					},
				},
			}, Users.Columns.Names(), opts...)
		},
		ResponseEmailLogEmailLog: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*CommsEmailLog, CommsEmailLogSlice](psql.PreloadRel{
				Name: "ResponseEmailLogEmailLog",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          CommsEmailLogs,
						FromColumns: []string{"response_email_log_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, CommsEmailLogs.Columns.Names(), opts...)
		},
		ResponseTextLogTextLog: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*CommsTextLog, CommsTextLogSlice](psql.PreloadRel{
				Name: "ResponseTextLogTextLog",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          CommsTextLogs,
						FromColumns: []string{"response_text_log_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, CommsTextLogs.Columns.Names(), opts...)
		},
		SetPendingByUser: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*User, UserSlice](psql.PreloadRel{
				Name: "SetPendingByUser",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          Users,
						FromColumns: []string{"set_pending_by"},
						ToColumns:   []string{"id"},
					},
				},
			}, Users.Columns.Names(), opts...)
		},
		SourceEmailLogEmailLog: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*CommsEmailLog, CommsEmailLogSlice](psql.PreloadRel{
				Name: "SourceEmailLogEmailLog",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          CommsEmailLogs,
						FromColumns: []string{"source_email_log_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, CommsEmailLogs.Columns.Names(), opts...)
		},
		SourceReportReport: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*PublicreportReport, PublicreportReportSlice](psql.PreloadRel{
				Name: "SourceReportReport",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          PublicreportReports,
						FromColumns: []string{"source_report_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, PublicreportReports.Columns.Names(), opts...)
		},
		SourceTextLogTextLog: func(opts ...psql.PreloadOption) psql.Preloader {
			return psql.Preload[*CommsTextLog, CommsTextLogSlice](psql.PreloadRel{
				Name: "SourceTextLogTextLog",
				Sides: []psql.PreloadSide{
					{
						From:        Communications,
						To:          CommsTextLogs,
						FromColumns: []string{"source_text_log_id"},
						ToColumns:   []string{"id"},
					},
				},
			}, CommsTextLogs.Columns.Names(), opts...)
		},
	}
}

type communicationThenLoader[Q orm.Loadable] struct {
	ClosedByUser             func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	InvalidatedByUser        func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	OpenedByUser             func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	ResponseEmailLogEmailLog func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	ResponseTextLogTextLog   func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	SetPendingByUser         func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	SourceEmailLogEmailLog   func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	SourceReportReport       func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
	SourceTextLogTextLog     func(...bob.Mod[*dialect.SelectQuery]) orm.Loader[Q]
}

func buildCommunicationThenLoader[Q orm.Loadable]() communicationThenLoader[Q] {
	type ClosedByUserLoadInterface interface {
		LoadClosedByUser(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type InvalidatedByUserLoadInterface interface {
		LoadInvalidatedByUser(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type OpenedByUserLoadInterface interface {
		LoadOpenedByUser(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ResponseEmailLogEmailLogLoadInterface interface {
		LoadResponseEmailLogEmailLog(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type ResponseTextLogTextLogLoadInterface interface {
		LoadResponseTextLogTextLog(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SetPendingByUserLoadInterface interface {
		LoadSetPendingByUser(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SourceEmailLogEmailLogLoadInterface interface {
		LoadSourceEmailLogEmailLog(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SourceReportReportLoadInterface interface {
		LoadSourceReportReport(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}
	type SourceTextLogTextLogLoadInterface interface {
		LoadSourceTextLogTextLog(context.Context, bob.Executor, ...bob.Mod[*dialect.SelectQuery]) error
	}

	return communicationThenLoader[Q]{
		ClosedByUser: thenLoadBuilder[Q](
			"ClosedByUser",
			func(ctx context.Context, exec bob.Executor, retrieved ClosedByUserLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadClosedByUser(ctx, exec, mods...)
			},
		),
		InvalidatedByUser: thenLoadBuilder[Q](
			"InvalidatedByUser",
			func(ctx context.Context, exec bob.Executor, retrieved InvalidatedByUserLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadInvalidatedByUser(ctx, exec, mods...)
			},
		),
		OpenedByUser: thenLoadBuilder[Q](
			"OpenedByUser",
			func(ctx context.Context, exec bob.Executor, retrieved OpenedByUserLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadOpenedByUser(ctx, exec, mods...)
			},
		),
		ResponseEmailLogEmailLog: thenLoadBuilder[Q](
			"ResponseEmailLogEmailLog",
			func(ctx context.Context, exec bob.Executor, retrieved ResponseEmailLogEmailLogLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadResponseEmailLogEmailLog(ctx, exec, mods...)
			},
		),
		ResponseTextLogTextLog: thenLoadBuilder[Q](
			"ResponseTextLogTextLog",
			func(ctx context.Context, exec bob.Executor, retrieved ResponseTextLogTextLogLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadResponseTextLogTextLog(ctx, exec, mods...)
			},
		),
		SetPendingByUser: thenLoadBuilder[Q](
			"SetPendingByUser",
			func(ctx context.Context, exec bob.Executor, retrieved SetPendingByUserLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSetPendingByUser(ctx, exec, mods...)
			},
		),
		SourceEmailLogEmailLog: thenLoadBuilder[Q](
			"SourceEmailLogEmailLog",
			func(ctx context.Context, exec bob.Executor, retrieved SourceEmailLogEmailLogLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSourceEmailLogEmailLog(ctx, exec, mods...)
			},
		),
		SourceReportReport: thenLoadBuilder[Q](
			"SourceReportReport",
			func(ctx context.Context, exec bob.Executor, retrieved SourceReportReportLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSourceReportReport(ctx, exec, mods...)
			},
		),
		SourceTextLogTextLog: thenLoadBuilder[Q](
			"SourceTextLogTextLog",
			func(ctx context.Context, exec bob.Executor, retrieved SourceTextLogTextLogLoadInterface, mods ...bob.Mod[*dialect.SelectQuery]) error {
				return retrieved.LoadSourceTextLogTextLog(ctx, exec, mods...)
			},
		),
	}
}

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

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

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

	related.R.ClosedByCommunications = CommunicationSlice{o}

	o.R.ClosedByUser = related
	return nil
}

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

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

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

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

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

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

			o.R.ClosedByUser = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.InvalidatedByCommunications = CommunicationSlice{o}

	o.R.InvalidatedByUser = related
	return nil
}

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

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

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

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

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

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

			o.R.InvalidatedByUser = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.OpenedByCommunications = CommunicationSlice{o}

	o.R.OpenedByUser = related
	return nil
}

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

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

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

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

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

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

			o.R.OpenedByUser = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.ResponseEmailLogCommunications = CommunicationSlice{o}

	o.R.ResponseEmailLogEmailLog = related
	return nil
}

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

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

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

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

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

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

			o.R.ResponseEmailLogEmailLog = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.ResponseTextLogCommunications = CommunicationSlice{o}

	o.R.ResponseTextLogTextLog = related
	return nil
}

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

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

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

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

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

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

			o.R.ResponseTextLogTextLog = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.SetPendingByCommunications = CommunicationSlice{o}

	o.R.SetPendingByUser = related
	return nil
}

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

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

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

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

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

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

			o.R.SetPendingByUser = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.SourceEmailLogCommunications = CommunicationSlice{o}

	o.R.SourceEmailLogEmailLog = related
	return nil
}

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

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

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

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

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

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

			o.R.SourceEmailLogEmailLog = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.SourceReportCommunications = CommunicationSlice{o}

	o.R.SourceReportReport = related
	return nil
}

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

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

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

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

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

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

			o.R.SourceReportReport = rel
			break
		}
	}

	return nil
}

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

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

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

	related.R.SourceTextLogCommunications = CommunicationSlice{o}

	o.R.SourceTextLogTextLog = related
	return nil
}

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

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

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

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

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

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

			o.R.SourceTextLogTextLog = rel
			break
		}
	}

	return nil
}