nidus-sync/db/enums/enums.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 enums

import (
	"database/sql/driver"
	"fmt"
)

// Enum values for Arcgislicensetype
const (
	ArcgislicensetypeAdvancedut             Arcgislicensetype = "advancedUT"
	ArcgislicensetypeBasicut                Arcgislicensetype = "basicUT"
	ArcgislicensetypeCreatorut              Arcgislicensetype = "creatorUT"
	ArcgislicensetypeEditorut               Arcgislicensetype = "editorUT"
	ArcgislicensetypeFieldworkerut          Arcgislicensetype = "fieldWorkerUT"
	ArcgislicensetypeGisprofessionaladvut   Arcgislicensetype = "GISProfessionalAdvUT"
	ArcgislicensetypeGisprofessionalbasicut Arcgislicensetype = "GISProfessionalBasicUT"
	ArcgislicensetypeGisprofessionalstdut   Arcgislicensetype = "GISProfessionalStdUT"
	ArcgislicensetypeIndoorsuserut          Arcgislicensetype = "IndoorsUserUT"
	ArcgislicensetypeInsightsanalystut      Arcgislicensetype = "insightsAnalystUT"
	ArcgislicensetypeLiteut                 Arcgislicensetype = "liteUT"
	ArcgislicensetypeStandardut             Arcgislicensetype = "standardUT"
	ArcgislicensetypeStorytellerut          Arcgislicensetype = "storytellerUT"
	ArcgislicensetypeViewerut               Arcgislicensetype = "viewerUT"
)

func AllArcgislicensetype() []Arcgislicensetype {
	return []Arcgislicensetype{
		ArcgislicensetypeAdvancedut,
		ArcgislicensetypeBasicut,
		ArcgislicensetypeCreatorut,
		ArcgislicensetypeEditorut,
		ArcgislicensetypeFieldworkerut,
		ArcgislicensetypeGisprofessionaladvut,
		ArcgislicensetypeGisprofessionalbasicut,
		ArcgislicensetypeGisprofessionalstdut,
		ArcgislicensetypeIndoorsuserut,
		ArcgislicensetypeInsightsanalystut,
		ArcgislicensetypeLiteut,
		ArcgislicensetypeStandardut,
		ArcgislicensetypeStorytellerut,
		ArcgislicensetypeViewerut,
	}
}

type Arcgislicensetype string

func (e Arcgislicensetype) String() string {
	return string(e)
}

func (e Arcgislicensetype) Valid() bool {
	switch e {
	case ArcgislicensetypeAdvancedut,
		ArcgislicensetypeBasicut,
		ArcgislicensetypeCreatorut,
		ArcgislicensetypeEditorut,
		ArcgislicensetypeFieldworkerut,
		ArcgislicensetypeGisprofessionaladvut,
		ArcgislicensetypeGisprofessionalbasicut,
		ArcgislicensetypeGisprofessionalstdut,
		ArcgislicensetypeIndoorsuserut,
		ArcgislicensetypeInsightsanalystut,
		ArcgislicensetypeLiteut,
		ArcgislicensetypeStandardut,
		ArcgislicensetypeStorytellerut,
		ArcgislicensetypeViewerut:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e Arcgislicensetype) All() []Arcgislicensetype {
	return AllArcgislicensetype()
}

func (e Arcgislicensetype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *Arcgislicensetype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e Arcgislicensetype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *Arcgislicensetype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e Arcgislicensetype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *Arcgislicensetype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = Arcgislicensetype(x)
	case []byte:
		*e = Arcgislicensetype(x)
	case nil:
		return fmt.Errorf("cannot nil into Arcgislicensetype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid Arcgislicensetype value: %s", *e)
	}

	return nil
}

// Enum values for Audiodatatype
const (
	AudiodatatypeRaw           Audiodatatype = "raw"
	AudiodatatypeRawNormalized Audiodatatype = "raw_normalized"
	AudiodatatypeOgg           Audiodatatype = "ogg"
)

func AllAudiodatatype() []Audiodatatype {
	return []Audiodatatype{
		AudiodatatypeRaw,
		AudiodatatypeRawNormalized,
		AudiodatatypeOgg,
	}
}

type Audiodatatype string

func (e Audiodatatype) String() string {
	return string(e)
}

func (e Audiodatatype) Valid() bool {
	switch e {
	case AudiodatatypeRaw,
		AudiodatatypeRawNormalized,
		AudiodatatypeOgg:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e Audiodatatype) All() []Audiodatatype {
	return AllAudiodatatype()
}

func (e Audiodatatype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *Audiodatatype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e Audiodatatype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *Audiodatatype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e Audiodatatype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *Audiodatatype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = Audiodatatype(x)
	case []byte:
		*e = Audiodatatype(x)
	case nil:
		return fmt.Errorf("cannot nil into Audiodatatype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid Audiodatatype value: %s", *e)
	}

	return nil
}

// Enum values for CommsMessagetypeemail
const (
	CommsMessagetypeemailInitialContact                 CommsMessagetypeemail = "initial-contact"
	CommsMessagetypeemailReportSubscriptionConfirmation CommsMessagetypeemail = "report-subscription-confirmation"
	CommsMessagetypeemailReportStatusScheduled          CommsMessagetypeemail = "report-status-scheduled"
	CommsMessagetypeemailReportStatusComplete           CommsMessagetypeemail = "report-status-complete"
)

func AllCommsMessagetypeemail() []CommsMessagetypeemail {
	return []CommsMessagetypeemail{
		CommsMessagetypeemailInitialContact,
		CommsMessagetypeemailReportSubscriptionConfirmation,
		CommsMessagetypeemailReportStatusScheduled,
		CommsMessagetypeemailReportStatusComplete,
	}
}

type CommsMessagetypeemail string

func (e CommsMessagetypeemail) String() string {
	return string(e)
}

func (e CommsMessagetypeemail) Valid() bool {
	switch e {
	case CommsMessagetypeemailInitialContact,
		CommsMessagetypeemailReportSubscriptionConfirmation,
		CommsMessagetypeemailReportStatusScheduled,
		CommsMessagetypeemailReportStatusComplete:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e CommsMessagetypeemail) All() []CommsMessagetypeemail {
	return AllCommsMessagetypeemail()
}

func (e CommsMessagetypeemail) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsMessagetypeemail) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e CommsMessagetypeemail) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsMessagetypeemail) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e CommsMessagetypeemail) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *CommsMessagetypeemail) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = CommsMessagetypeemail(x)
	case []byte:
		*e = CommsMessagetypeemail(x)
	case nil:
		return fmt.Errorf("cannot nil into CommsMessagetypeemail")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid CommsMessagetypeemail value: %s", *e)
	}

	return nil
}

// Enum values for CommsPhonestatustype
const (
	CommsPhonestatustypeUnconfirmed CommsPhonestatustype = "unconfirmed"
	CommsPhonestatustypeOkToSend    CommsPhonestatustype = "ok-to-send"
	CommsPhonestatustypeStopped     CommsPhonestatustype = "stopped"
)

func AllCommsPhonestatustype() []CommsPhonestatustype {
	return []CommsPhonestatustype{
		CommsPhonestatustypeUnconfirmed,
		CommsPhonestatustypeOkToSend,
		CommsPhonestatustypeStopped,
	}
}

type CommsPhonestatustype string

func (e CommsPhonestatustype) String() string {
	return string(e)
}

func (e CommsPhonestatustype) Valid() bool {
	switch e {
	case CommsPhonestatustypeUnconfirmed,
		CommsPhonestatustypeOkToSend,
		CommsPhonestatustypeStopped:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e CommsPhonestatustype) All() []CommsPhonestatustype {
	return AllCommsPhonestatustype()
}

func (e CommsPhonestatustype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsPhonestatustype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e CommsPhonestatustype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsPhonestatustype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e CommsPhonestatustype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *CommsPhonestatustype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = CommsPhonestatustype(x)
	case []byte:
		*e = CommsPhonestatustype(x)
	case nil:
		return fmt.Errorf("cannot nil into CommsPhonestatustype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid CommsPhonestatustype value: %s", *e)
	}

	return nil
}

// Enum values for CommsTextjobsource
const (
	CommsTextjobsourceRmo   CommsTextjobsource = "rmo"
	CommsTextjobsourceNidus CommsTextjobsource = "nidus"
)

func AllCommsTextjobsource() []CommsTextjobsource {
	return []CommsTextjobsource{
		CommsTextjobsourceRmo,
		CommsTextjobsourceNidus,
	}
}

type CommsTextjobsource string

func (e CommsTextjobsource) String() string {
	return string(e)
}

func (e CommsTextjobsource) Valid() bool {
	switch e {
	case CommsTextjobsourceRmo,
		CommsTextjobsourceNidus:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e CommsTextjobsource) All() []CommsTextjobsource {
	return AllCommsTextjobsource()
}

func (e CommsTextjobsource) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextjobsource) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e CommsTextjobsource) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextjobsource) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e CommsTextjobsource) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *CommsTextjobsource) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = CommsTextjobsource(x)
	case []byte:
		*e = CommsTextjobsource(x)
	case nil:
		return fmt.Errorf("cannot nil into CommsTextjobsource")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid CommsTextjobsource value: %s", *e)
	}

	return nil
}

// Enum values for CommsTextjobtype
const (
	CommsTextjobtypeReportConfirmation CommsTextjobtype = "report-confirmation"
)

func AllCommsTextjobtype() []CommsTextjobtype {
	return []CommsTextjobtype{
		CommsTextjobtypeReportConfirmation,
	}
}

type CommsTextjobtype string

func (e CommsTextjobtype) String() string {
	return string(e)
}

func (e CommsTextjobtype) Valid() bool {
	switch e {
	case CommsTextjobtypeReportConfirmation:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e CommsTextjobtype) All() []CommsTextjobtype {
	return AllCommsTextjobtype()
}

func (e CommsTextjobtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextjobtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e CommsTextjobtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextjobtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e CommsTextjobtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *CommsTextjobtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = CommsTextjobtype(x)
	case []byte:
		*e = CommsTextjobtype(x)
	case nil:
		return fmt.Errorf("cannot nil into CommsTextjobtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid CommsTextjobtype value: %s", *e)
	}

	return nil
}

// Enum values for CommsTextorigin
const (
	CommsTextoriginDistrict        CommsTextorigin = "district"
	CommsTextoriginLLM             CommsTextorigin = "llm"
	CommsTextoriginWebsiteAction   CommsTextorigin = "website-action"
	CommsTextoriginCustomer        CommsTextorigin = "customer"
	CommsTextoriginReiteration     CommsTextorigin = "reiteration"
	CommsTextoriginCommandResponse CommsTextorigin = "command-response"
)

func AllCommsTextorigin() []CommsTextorigin {
	return []CommsTextorigin{
		CommsTextoriginDistrict,
		CommsTextoriginLLM,
		CommsTextoriginWebsiteAction,
		CommsTextoriginCustomer,
		CommsTextoriginReiteration,
		CommsTextoriginCommandResponse,
	}
}

type CommsTextorigin string

func (e CommsTextorigin) String() string {
	return string(e)
}

func (e CommsTextorigin) Valid() bool {
	switch e {
	case CommsTextoriginDistrict,
		CommsTextoriginLLM,
		CommsTextoriginWebsiteAction,
		CommsTextoriginCustomer,
		CommsTextoriginReiteration,
		CommsTextoriginCommandResponse:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e CommsTextorigin) All() []CommsTextorigin {
	return AllCommsTextorigin()
}

func (e CommsTextorigin) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextorigin) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e CommsTextorigin) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *CommsTextorigin) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e CommsTextorigin) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *CommsTextorigin) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = CommsTextorigin(x)
	case []byte:
		*e = CommsTextorigin(x)
	case nil:
		return fmt.Errorf("cannot nil into CommsTextorigin")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid CommsTextorigin value: %s", *e)
	}

	return nil
}

// Enum values for H3aggregationtype
const (
	H3aggregationtypeMosquitosource H3aggregationtype = "MosquitoSource"
	H3aggregationtypeServicerequest H3aggregationtype = "ServiceRequest"
	H3aggregationtypeTrap           H3aggregationtype = "Trap"
)

func AllH3aggregationtype() []H3aggregationtype {
	return []H3aggregationtype{
		H3aggregationtypeMosquitosource,
		H3aggregationtypeServicerequest,
		H3aggregationtypeTrap,
	}
}

type H3aggregationtype string

func (e H3aggregationtype) String() string {
	return string(e)
}

func (e H3aggregationtype) Valid() bool {
	switch e {
	case H3aggregationtypeMosquitosource,
		H3aggregationtypeServicerequest,
		H3aggregationtypeTrap:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e H3aggregationtype) All() []H3aggregationtype {
	return AllH3aggregationtype()
}

func (e H3aggregationtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *H3aggregationtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e H3aggregationtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *H3aggregationtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e H3aggregationtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *H3aggregationtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = H3aggregationtype(x)
	case []byte:
		*e = H3aggregationtype(x)
	case nil:
		return fmt.Errorf("cannot nil into H3aggregationtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid H3aggregationtype value: %s", *e)
	}

	return nil
}

// Enum values for Hashtype
const (
	HashtypeBcrypt14 Hashtype = "bcrypt-14"
)

func AllHashtype() []Hashtype {
	return []Hashtype{
		HashtypeBcrypt14,
	}
}

type Hashtype string

func (e Hashtype) String() string {
	return string(e)
}

func (e Hashtype) Valid() bool {
	switch e {
	case HashtypeBcrypt14:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e Hashtype) All() []Hashtype {
	return AllHashtype()
}

func (e Hashtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *Hashtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e Hashtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *Hashtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e Hashtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *Hashtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = Hashtype(x)
	case []byte:
		*e = Hashtype(x)
	case nil:
		return fmt.Errorf("cannot nil into Hashtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid Hashtype value: %s", *e)
	}

	return nil
}

// Enum values for Imagedatatype
const (
	ImagedatatypeRaw Imagedatatype = "raw"
	ImagedatatypePNG Imagedatatype = "png"
)

func AllImagedatatype() []Imagedatatype {
	return []Imagedatatype{
		ImagedatatypeRaw,
		ImagedatatypePNG,
	}
}

type Imagedatatype string

func (e Imagedatatype) String() string {
	return string(e)
}

func (e Imagedatatype) Valid() bool {
	switch e {
	case ImagedatatypeRaw, ImagedatatypePNG:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e Imagedatatype) All() []Imagedatatype {
	return AllImagedatatype()
}

func (e Imagedatatype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *Imagedatatype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e Imagedatatype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *Imagedatatype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e Imagedatatype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *Imagedatatype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = Imagedatatype(x)
	case []byte:
		*e = Imagedatatype(x)
	case nil:
		return fmt.Errorf("cannot nil into Imagedatatype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid Imagedatatype value: %s", *e)
	}

	return nil
}

// Enum values for Notificationtype
const (
	NotificationtypeOauthTokenInvalidated Notificationtype = "oauth_token_invalidated"
)

func AllNotificationtype() []Notificationtype {
	return []Notificationtype{
		NotificationtypeOauthTokenInvalidated,
	}
}

type Notificationtype string

func (e Notificationtype) String() string {
	return string(e)
}

func (e Notificationtype) Valid() bool {
	switch e {
	case NotificationtypeOauthTokenInvalidated:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e Notificationtype) All() []Notificationtype {
	return AllNotificationtype()
}

func (e Notificationtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *Notificationtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e Notificationtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *Notificationtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e Notificationtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *Notificationtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = Notificationtype(x)
	case []byte:
		*e = Notificationtype(x)
	case nil:
		return fmt.Errorf("cannot nil into Notificationtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid Notificationtype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportNuisancedurationtype
const (
	PublicreportNuisancedurationtypeNone        PublicreportNuisancedurationtype = "none"
	PublicreportNuisancedurationtypeJustNoticed PublicreportNuisancedurationtype = "just-noticed"
	PublicreportNuisancedurationtypeFewDays     PublicreportNuisancedurationtype = "few-days"
	PublicreportNuisancedurationtype12Weeks     PublicreportNuisancedurationtype = "1-2-weeks"
	PublicreportNuisancedurationtype24Weeks     PublicreportNuisancedurationtype = "2-4-weeks"
	PublicreportNuisancedurationtype13Months    PublicreportNuisancedurationtype = "1-3-months"
	PublicreportNuisancedurationtypeSeasonal    PublicreportNuisancedurationtype = "seasonal"
)

func AllPublicreportNuisancedurationtype() []PublicreportNuisancedurationtype {
	return []PublicreportNuisancedurationtype{
		PublicreportNuisancedurationtypeNone,
		PublicreportNuisancedurationtypeJustNoticed,
		PublicreportNuisancedurationtypeFewDays,
		PublicreportNuisancedurationtype12Weeks,
		PublicreportNuisancedurationtype24Weeks,
		PublicreportNuisancedurationtype13Months,
		PublicreportNuisancedurationtypeSeasonal,
	}
}

type PublicreportNuisancedurationtype string

func (e PublicreportNuisancedurationtype) String() string {
	return string(e)
}

func (e PublicreportNuisancedurationtype) Valid() bool {
	switch e {
	case PublicreportNuisancedurationtypeNone,
		PublicreportNuisancedurationtypeJustNoticed,
		PublicreportNuisancedurationtypeFewDays,
		PublicreportNuisancedurationtype12Weeks,
		PublicreportNuisancedurationtype24Weeks,
		PublicreportNuisancedurationtype13Months,
		PublicreportNuisancedurationtypeSeasonal:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportNuisancedurationtype) All() []PublicreportNuisancedurationtype {
	return AllPublicreportNuisancedurationtype()
}

func (e PublicreportNuisancedurationtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancedurationtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportNuisancedurationtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancedurationtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportNuisancedurationtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportNuisancedurationtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportNuisancedurationtype(x)
	case []byte:
		*e = PublicreportNuisancedurationtype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportNuisancedurationtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportNuisancedurationtype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportNuisanceinspectiontype
const (
	PublicreportNuisanceinspectiontypeNeighborhood PublicreportNuisanceinspectiontype = "neighborhood"
	PublicreportNuisanceinspectiontypeProperty     PublicreportNuisanceinspectiontype = "property"
)

func AllPublicreportNuisanceinspectiontype() []PublicreportNuisanceinspectiontype {
	return []PublicreportNuisanceinspectiontype{
		PublicreportNuisanceinspectiontypeNeighborhood,
		PublicreportNuisanceinspectiontypeProperty,
	}
}

type PublicreportNuisanceinspectiontype string

func (e PublicreportNuisanceinspectiontype) String() string {
	return string(e)
}

func (e PublicreportNuisanceinspectiontype) Valid() bool {
	switch e {
	case PublicreportNuisanceinspectiontypeNeighborhood,
		PublicreportNuisanceinspectiontypeProperty:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportNuisanceinspectiontype) All() []PublicreportNuisanceinspectiontype {
	return AllPublicreportNuisanceinspectiontype()
}

func (e PublicreportNuisanceinspectiontype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisanceinspectiontype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportNuisanceinspectiontype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisanceinspectiontype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportNuisanceinspectiontype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportNuisanceinspectiontype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportNuisanceinspectiontype(x)
	case []byte:
		*e = PublicreportNuisanceinspectiontype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportNuisanceinspectiontype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportNuisanceinspectiontype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportNuisancelocationtype
const (
	PublicreportNuisancelocationtypeNone       PublicreportNuisancelocationtype = "none"
	PublicreportNuisancelocationtypeFrontYard  PublicreportNuisancelocationtype = "front-yard"
	PublicreportNuisancelocationtypeBackyard   PublicreportNuisancelocationtype = "backyard"
	PublicreportNuisancelocationtypePatio      PublicreportNuisancelocationtype = "patio"
	PublicreportNuisancelocationtypeGarden     PublicreportNuisancelocationtype = "garden"
	PublicreportNuisancelocationtypePoolArea   PublicreportNuisancelocationtype = "pool-area"
	PublicreportNuisancelocationtypeThroughout PublicreportNuisancelocationtype = "throughout"
	PublicreportNuisancelocationtypeIndoors    PublicreportNuisancelocationtype = "indoors"
	PublicreportNuisancelocationtypeOther      PublicreportNuisancelocationtype = "other"
)

func AllPublicreportNuisancelocationtype() []PublicreportNuisancelocationtype {
	return []PublicreportNuisancelocationtype{
		PublicreportNuisancelocationtypeNone,
		PublicreportNuisancelocationtypeFrontYard,
		PublicreportNuisancelocationtypeBackyard,
		PublicreportNuisancelocationtypePatio,
		PublicreportNuisancelocationtypeGarden,
		PublicreportNuisancelocationtypePoolArea,
		PublicreportNuisancelocationtypeThroughout,
		PublicreportNuisancelocationtypeIndoors,
		PublicreportNuisancelocationtypeOther,
	}
}

type PublicreportNuisancelocationtype string

func (e PublicreportNuisancelocationtype) String() string {
	return string(e)
}

func (e PublicreportNuisancelocationtype) Valid() bool {
	switch e {
	case PublicreportNuisancelocationtypeNone,
		PublicreportNuisancelocationtypeFrontYard,
		PublicreportNuisancelocationtypeBackyard,
		PublicreportNuisancelocationtypePatio,
		PublicreportNuisancelocationtypeGarden,
		PublicreportNuisancelocationtypePoolArea,
		PublicreportNuisancelocationtypeThroughout,
		PublicreportNuisancelocationtypeIndoors,
		PublicreportNuisancelocationtypeOther:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportNuisancelocationtype) All() []PublicreportNuisancelocationtype {
	return AllPublicreportNuisancelocationtype()
}

func (e PublicreportNuisancelocationtype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancelocationtype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportNuisancelocationtype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancelocationtype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportNuisancelocationtype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportNuisancelocationtype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportNuisancelocationtype(x)
	case []byte:
		*e = PublicreportNuisancelocationtype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportNuisancelocationtype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportNuisancelocationtype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportNuisancepreferreddaterangetype
const (
	PublicreportNuisancepreferreddaterangetypeNone       PublicreportNuisancepreferreddaterangetype = "none"
	PublicreportNuisancepreferreddaterangetypeAnyTime    PublicreportNuisancepreferreddaterangetype = "any-time"
	PublicreportNuisancepreferreddaterangetypeInTwoWeeks PublicreportNuisancepreferreddaterangetype = "in-two-weeks"
	PublicreportNuisancepreferreddaterangetypeNextWeek   PublicreportNuisancepreferreddaterangetype = "next-week"
)

func AllPublicreportNuisancepreferreddaterangetype() []PublicreportNuisancepreferreddaterangetype {
	return []PublicreportNuisancepreferreddaterangetype{
		PublicreportNuisancepreferreddaterangetypeNone,
		PublicreportNuisancepreferreddaterangetypeAnyTime,
		PublicreportNuisancepreferreddaterangetypeInTwoWeeks,
		PublicreportNuisancepreferreddaterangetypeNextWeek,
	}
}

type PublicreportNuisancepreferreddaterangetype string

func (e PublicreportNuisancepreferreddaterangetype) String() string {
	return string(e)
}

func (e PublicreportNuisancepreferreddaterangetype) Valid() bool {
	switch e {
	case PublicreportNuisancepreferreddaterangetypeNone,
		PublicreportNuisancepreferreddaterangetypeAnyTime,
		PublicreportNuisancepreferreddaterangetypeInTwoWeeks,
		PublicreportNuisancepreferreddaterangetypeNextWeek:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportNuisancepreferreddaterangetype) All() []PublicreportNuisancepreferreddaterangetype {
	return AllPublicreportNuisancepreferreddaterangetype()
}

func (e PublicreportNuisancepreferreddaterangetype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancepreferreddaterangetype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportNuisancepreferreddaterangetype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancepreferreddaterangetype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportNuisancepreferreddaterangetype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportNuisancepreferreddaterangetype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportNuisancepreferreddaterangetype(x)
	case []byte:
		*e = PublicreportNuisancepreferreddaterangetype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportNuisancepreferreddaterangetype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportNuisancepreferreddaterangetype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportNuisancepreferredtimetype
const (
	PublicreportNuisancepreferredtimetypeNone      PublicreportNuisancepreferredtimetype = "none"
	PublicreportNuisancepreferredtimetypeAfternoon PublicreportNuisancepreferredtimetype = "afternoon"
	PublicreportNuisancepreferredtimetypeAnyTime   PublicreportNuisancepreferredtimetype = "any-time"
	PublicreportNuisancepreferredtimetypeMorning   PublicreportNuisancepreferredtimetype = "morning"
)

func AllPublicreportNuisancepreferredtimetype() []PublicreportNuisancepreferredtimetype {
	return []PublicreportNuisancepreferredtimetype{
		PublicreportNuisancepreferredtimetypeNone,
		PublicreportNuisancepreferredtimetypeAfternoon,
		PublicreportNuisancepreferredtimetypeAnyTime,
		PublicreportNuisancepreferredtimetypeMorning,
	}
}

type PublicreportNuisancepreferredtimetype string

func (e PublicreportNuisancepreferredtimetype) String() string {
	return string(e)
}

func (e PublicreportNuisancepreferredtimetype) Valid() bool {
	switch e {
	case PublicreportNuisancepreferredtimetypeNone,
		PublicreportNuisancepreferredtimetypeAfternoon,
		PublicreportNuisancepreferredtimetypeAnyTime,
		PublicreportNuisancepreferredtimetypeMorning:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportNuisancepreferredtimetype) All() []PublicreportNuisancepreferredtimetype {
	return AllPublicreportNuisancepreferredtimetype()
}

func (e PublicreportNuisancepreferredtimetype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancepreferredtimetype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportNuisancepreferredtimetype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportNuisancepreferredtimetype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportNuisancepreferredtimetype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportNuisancepreferredtimetype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportNuisancepreferredtimetype(x)
	case []byte:
		*e = PublicreportNuisancepreferredtimetype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportNuisancepreferredtimetype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportNuisancepreferredtimetype value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportPoolsourceduration
const (
	PublicreportPoolsourcedurationNone            PublicreportPoolsourceduration = "none"
	PublicreportPoolsourcedurationLessThanWeek    PublicreportPoolsourceduration = "less-than-week"
	PublicreportPoolsourceduration12Weeks         PublicreportPoolsourceduration = "1-2-weeks"
	PublicreportPoolsourceduration24Weeks         PublicreportPoolsourceduration = "2-4-weeks"
	PublicreportPoolsourceduration13Months        PublicreportPoolsourceduration = "1-3-months"
	PublicreportPoolsourcedurationMoreThan3Months PublicreportPoolsourceduration = "more-than-3-months"
)

func AllPublicreportPoolsourceduration() []PublicreportPoolsourceduration {
	return []PublicreportPoolsourceduration{
		PublicreportPoolsourcedurationNone,
		PublicreportPoolsourcedurationLessThanWeek,
		PublicreportPoolsourceduration12Weeks,
		PublicreportPoolsourceduration24Weeks,
		PublicreportPoolsourceduration13Months,
		PublicreportPoolsourcedurationMoreThan3Months,
	}
}

type PublicreportPoolsourceduration string

func (e PublicreportPoolsourceduration) String() string {
	return string(e)
}

func (e PublicreportPoolsourceduration) Valid() bool {
	switch e {
	case PublicreportPoolsourcedurationNone,
		PublicreportPoolsourcedurationLessThanWeek,
		PublicreportPoolsourceduration12Weeks,
		PublicreportPoolsourceduration24Weeks,
		PublicreportPoolsourceduration13Months,
		PublicreportPoolsourcedurationMoreThan3Months:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportPoolsourceduration) All() []PublicreportPoolsourceduration {
	return AllPublicreportPoolsourceduration()
}

func (e PublicreportPoolsourceduration) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportPoolsourceduration) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportPoolsourceduration) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportPoolsourceduration) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportPoolsourceduration) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportPoolsourceduration) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportPoolsourceduration(x)
	case []byte:
		*e = PublicreportPoolsourceduration(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportPoolsourceduration")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportPoolsourceduration value: %s", *e)
	}

	return nil
}

// Enum values for PublicreportReportstatustype
const (
	PublicreportReportstatustypeReported  PublicreportReportstatustype = "reported"
	PublicreportReportstatustypeReviewed  PublicreportReportstatustype = "reviewed"
	PublicreportReportstatustypeScheduled PublicreportReportstatustype = "scheduled"
	PublicreportReportstatustypeTreated   PublicreportReportstatustype = "treated"
)

func AllPublicreportReportstatustype() []PublicreportReportstatustype {
	return []PublicreportReportstatustype{
		PublicreportReportstatustypeReported,
		PublicreportReportstatustypeReviewed,
		PublicreportReportstatustypeScheduled,
		PublicreportReportstatustypeTreated,
	}
}

type PublicreportReportstatustype string

func (e PublicreportReportstatustype) String() string {
	return string(e)
}

func (e PublicreportReportstatustype) Valid() bool {
	switch e {
	case PublicreportReportstatustypeReported,
		PublicreportReportstatustypeReviewed,
		PublicreportReportstatustypeScheduled,
		PublicreportReportstatustypeTreated:
		return true
	default:
		return false
	}
}

// useful when testing in other packages
func (e PublicreportReportstatustype) All() []PublicreportReportstatustype {
	return AllPublicreportReportstatustype()
}

func (e PublicreportReportstatustype) MarshalText() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportReportstatustype) UnmarshalText(text []byte) error {
	return e.Scan(text)
}

func (e PublicreportReportstatustype) MarshalBinary() ([]byte, error) {
	return []byte(e), nil
}

func (e *PublicreportReportstatustype) UnmarshalBinary(data []byte) error {
	return e.Scan(data)
}

func (e PublicreportReportstatustype) Value() (driver.Value, error) {
	return string(e), nil
}

func (e *PublicreportReportstatustype) Scan(value any) error {
	switch x := value.(type) {
	case string:
		*e = PublicreportReportstatustype(x)
	case []byte:
		*e = PublicreportReportstatustype(x)
	case nil:
		return fmt.Errorf("cannot nil into PublicreportReportstatustype")
	default:
		return fmt.Errorf("cannot scan type %T: %v", value, value)
	}

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportReportstatustype value: %s", *e)
	}

	return nil
}