// 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"
	CommsMessagetypeemailReportNotificationConfirmation CommsMessagetypeemail = "report-notification-confirmation"
)

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

type CommsMessagetypeemail string

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

func (e CommsMessagetypeemail) Valid() bool {
	switch e {
	case CommsMessagetypeemailInitialContact,
		CommsMessagetypeemailReportSubscriptionConfirmation,
		CommsMessagetypeemailReportStatusScheduled,
		CommsMessagetypeemailReportStatusComplete,
		CommsMessagetypeemailReportNotificationConfirmation:
		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"
	CommsTextjobtypeReportMessage      CommsTextjobtype = "report-message"
)

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

type CommsTextjobtype string

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

func (e CommsTextjobtype) Valid() bool {
	switch e {
	case CommsTextjobtypeReportConfirmation,
		CommsTextjobtypeReportMessage:
		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 Communicationlogentry
const (
	CommunicationlogentryCreated                   Communicationlogentry = "created"
	CommunicationlogentryStatusU2eclosed           Communicationlogentry = "status.closed"
	CommunicationlogentryStatusU2einvalidated      Communicationlogentry = "status.invalidated"
	CommunicationlogentryStatusU2eopened           Communicationlogentry = "status.opened"
	CommunicationlogentryStatusU2epending          Communicationlogentry = "status.pending"
	CommunicationlogentryStatusU2epossibleIssue    Communicationlogentry = "status.possible-issue"
	CommunicationlogentryStatusU2epossibleResolved Communicationlogentry = "status.possible-resolved"
)

func AllCommunicationlogentry() []Communicationlogentry {
	return []Communicationlogentry{
		CommunicationlogentryCreated,
		CommunicationlogentryStatusU2eclosed,
		CommunicationlogentryStatusU2einvalidated,
		CommunicationlogentryStatusU2eopened,
		CommunicationlogentryStatusU2epending,
		CommunicationlogentryStatusU2epossibleIssue,
		CommunicationlogentryStatusU2epossibleResolved,
	}
}

type Communicationlogentry string

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

func (e Communicationlogentry) Valid() bool {
	switch e {
	case CommunicationlogentryCreated,
		CommunicationlogentryStatusU2eclosed,
		CommunicationlogentryStatusU2einvalidated,
		CommunicationlogentryStatusU2eopened,
		CommunicationlogentryStatusU2epending,
		CommunicationlogentryStatusU2epossibleIssue,
		CommunicationlogentryStatusU2epossibleResolved:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Communicationstatus
const (
	CommunicationstatusClosed           Communicationstatus = "closed"
	CommunicationstatusInvalid          Communicationstatus = "invalid"
	CommunicationstatusNew              Communicationstatus = "new"
	CommunicationstatusOpened           Communicationstatus = "opened"
	CommunicationstatusPending          Communicationstatus = "pending"
	CommunicationstatusPossibleIssue    Communicationstatus = "possible-issue"
	CommunicationstatusPossibleResolved Communicationstatus = "possible-resolved"
	CommunicationstatusResolved         Communicationstatus = "resolved"
)

func AllCommunicationstatus() []Communicationstatus {
	return []Communicationstatus{
		CommunicationstatusClosed,
		CommunicationstatusInvalid,
		CommunicationstatusNew,
		CommunicationstatusOpened,
		CommunicationstatusPending,
		CommunicationstatusPossibleIssue,
		CommunicationstatusPossibleResolved,
		CommunicationstatusResolved,
	}
}

type Communicationstatus string

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

func (e Communicationstatus) Valid() bool {
	switch e {
	case CommunicationstatusClosed,
		CommunicationstatusInvalid,
		CommunicationstatusNew,
		CommunicationstatusOpened,
		CommunicationstatusPending,
		CommunicationstatusPossibleIssue,
		CommunicationstatusPossibleResolved,
		CommunicationstatusResolved:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Communicationstatustype
const (
	CommunicationstatustypeClosed           Communicationstatustype = "closed"
	CommunicationstatustypeInvalid          Communicationstatustype = "invalid"
	CommunicationstatustypeNew              Communicationstatustype = "new"
	CommunicationstatustypeOpened           Communicationstatustype = "opened"
	CommunicationstatustypePending          Communicationstatustype = "pending"
	CommunicationstatustypePossibleIssue    Communicationstatustype = "possible-issue"
	CommunicationstatustypePossibleResolved Communicationstatustype = "possible-resolved"
	CommunicationstatustypeResolved         Communicationstatustype = "resolved"
)

func AllCommunicationstatustype() []Communicationstatustype {
	return []Communicationstatustype{
		CommunicationstatustypeClosed,
		CommunicationstatustypeInvalid,
		CommunicationstatustypeNew,
		CommunicationstatustypeOpened,
		CommunicationstatustypePending,
		CommunicationstatustypePossibleIssue,
		CommunicationstatustypePossibleResolved,
		CommunicationstatustypeResolved,
	}
}

type Communicationstatustype string

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

func (e Communicationstatustype) Valid() bool {
	switch e {
	case CommunicationstatustypeClosed,
		CommunicationstatustypeInvalid,
		CommunicationstatustypeNew,
		CommunicationstatustypeOpened,
		CommunicationstatustypePending,
		CommunicationstatustypePossibleIssue,
		CommunicationstatustypePossibleResolved,
		CommunicationstatustypeResolved:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for FileuploadCsvtype
const (
	FileuploadCsvtypePoollist FileuploadCsvtype = "PoolList"
	FileuploadCsvtypeFlyover  FileuploadCsvtype = "Flyover"
)

func AllFileuploadCsvtype() []FileuploadCsvtype {
	return []FileuploadCsvtype{
		FileuploadCsvtypePoollist,
		FileuploadCsvtypeFlyover,
	}
}

type FileuploadCsvtype string

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

func (e FileuploadCsvtype) Valid() bool {
	switch e {
	case FileuploadCsvtypePoollist,
		FileuploadCsvtypeFlyover:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for FileuploadFilestatustype
const (
	FileuploadFilestatustypeError      FileuploadFilestatustype = "error"
	FileuploadFilestatustypeParsed     FileuploadFilestatustype = "parsed"
	FileuploadFilestatustypeUploaded   FileuploadFilestatustype = "uploaded"
	FileuploadFilestatustypeParsing    FileuploadFilestatustype = "parsing"
	FileuploadFilestatustypeCommitting FileuploadFilestatustype = "committing"
	FileuploadFilestatustypeCommitted  FileuploadFilestatustype = "committed"
	FileuploadFilestatustypeDiscarded  FileuploadFilestatustype = "discarded"
)

func AllFileuploadFilestatustype() []FileuploadFilestatustype {
	return []FileuploadFilestatustype{
		FileuploadFilestatustypeError,
		FileuploadFilestatustypeParsed,
		FileuploadFilestatustypeUploaded,
		FileuploadFilestatustypeParsing,
		FileuploadFilestatustypeCommitting,
		FileuploadFilestatustypeCommitted,
		FileuploadFilestatustypeDiscarded,
	}
}

type FileuploadFilestatustype string

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

func (e FileuploadFilestatustype) Valid() bool {
	switch e {
	case FileuploadFilestatustypeError,
		FileuploadFilestatustypeParsed,
		FileuploadFilestatustypeUploaded,
		FileuploadFilestatustypeParsing,
		FileuploadFilestatustypeCommitting,
		FileuploadFilestatustypeCommitted,
		FileuploadFilestatustypeDiscarded:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

	if !e.Valid() {
		return fmt.Errorf("invalid FileuploadFilestatustype 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 Jobtype
const (
	JobtypeAudioTranscode         Jobtype = "audio-transcode"
	JobtypeCSVCommit              Jobtype = "csv-commit"
	JobtypeCSVImport              Jobtype = "csv-import"
	JobtypeLabelStudioAudioCreate Jobtype = "label-studio-audio-create"
	JobtypeEmailSend              Jobtype = "email-send"
	JobtypeTextRespond            Jobtype = "text-respond"
	JobtypeTextSend               Jobtype = "text-send"
	JobtypeComplianceMailerSend   Jobtype = "compliance-mailer-send"
)

func AllJobtype() []Jobtype {
	return []Jobtype{
		JobtypeAudioTranscode,
		JobtypeCSVCommit,
		JobtypeCSVImport,
		JobtypeLabelStudioAudioCreate,
		JobtypeEmailSend,
		JobtypeTextRespond,
		JobtypeTextSend,
		JobtypeComplianceMailerSend,
	}
}

type Jobtype string

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

func (e Jobtype) Valid() bool {
	switch e {
	case JobtypeAudioTranscode,
		JobtypeCSVCommit,
		JobtypeCSVImport,
		JobtypeLabelStudioAudioCreate,
		JobtypeEmailSend,
		JobtypeTextRespond,
		JobtypeTextSend,
		JobtypeComplianceMailerSend:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Leadtype
const (
	LeadtypeUnknown              Leadtype = "unknown"
	LeadtypeGreenPool            Leadtype = "green-pool"
	LeadtypePublicreportNuisance Leadtype = "publicreport-nuisance"
	LeadtypePublicreportWater    Leadtype = "publicreport-water"
)

func AllLeadtype() []Leadtype {
	return []Leadtype{
		LeadtypeUnknown,
		LeadtypeGreenPool,
		LeadtypePublicreportNuisance,
		LeadtypePublicreportWater,
	}
}

type Leadtype string

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

func (e Leadtype) Valid() bool {
	switch e {
	case LeadtypeUnknown,
		LeadtypeGreenPool,
		LeadtypePublicreportNuisance,
		LeadtypePublicreportWater:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Mosquitospecies
const (
	MosquitospeciesNone            Mosquitospecies = "none"
	MosquitospeciesAedesAegypti    Mosquitospecies = "aedes aegypti"
	MosquitospeciesAedesAlbopictus Mosquitospecies = "aedes albopictus"
	MosquitospeciesCulexPipiens    Mosquitospecies = "culex pipiens"
	MosquitospeciesCulexTarsalis   Mosquitospecies = "culex tarsalis"
)

func AllMosquitospecies() []Mosquitospecies {
	return []Mosquitospecies{
		MosquitospeciesNone,
		MosquitospeciesAedesAegypti,
		MosquitospeciesAedesAlbopictus,
		MosquitospeciesCulexPipiens,
		MosquitospeciesCulexTarsalis,
	}
}

type Mosquitospecies string

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

func (e Mosquitospecies) Valid() bool {
	switch e {
	case MosquitospeciesNone,
		MosquitospeciesAedesAegypti,
		MosquitospeciesAedesAlbopictus,
		MosquitospeciesCulexPipiens,
		MosquitospeciesCulexTarsalis:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

	if !e.Valid() {
		return fmt.Errorf("invalid Mosquitospecies 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 Poolconditiontype
const (
	PoolconditiontypeBlue      Poolconditiontype = "blue"
	PoolconditiontypeDry       Poolconditiontype = "dry"
	PoolconditiontypeFalsePool Poolconditiontype = "false pool"
	PoolconditiontypeUnknown   Poolconditiontype = "unknown"
	PoolconditiontypeGreen     Poolconditiontype = "green"
	PoolconditiontypeMurky     Poolconditiontype = "murky"
)

func AllPoolconditiontype() []Poolconditiontype {
	return []Poolconditiontype{
		PoolconditiontypeBlue,
		PoolconditiontypeDry,
		PoolconditiontypeFalsePool,
		PoolconditiontypeUnknown,
		PoolconditiontypeGreen,
		PoolconditiontypeMurky,
	}
}

type Poolconditiontype string

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

func (e Poolconditiontype) Valid() bool {
	switch e {
	case PoolconditiontypeBlue,
		PoolconditiontypeDry,
		PoolconditiontypeFalsePool,
		PoolconditiontypeUnknown,
		PoolconditiontypeGreen,
		PoolconditiontypeMurky:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for PublicreportAccuracytype
const (
	PublicreportAccuracytypeRooftop      PublicreportAccuracytype = "rooftop"
	PublicreportAccuracytypeParcel       PublicreportAccuracytype = "parcel"
	PublicreportAccuracytypePoint        PublicreportAccuracytype = "point"
	PublicreportAccuracytypeInterpolated PublicreportAccuracytype = "interpolated"
	PublicreportAccuracytypeApproximate  PublicreportAccuracytype = "approximate"
	PublicreportAccuracytypeIntersection PublicreportAccuracytype = "intersection"
	PublicreportAccuracytypeCentroid     PublicreportAccuracytype = "centroid"
	PublicreportAccuracytypeBrowser      PublicreportAccuracytype = "browser"
	PublicreportAccuracytypeNone         PublicreportAccuracytype = "none"
)

func AllPublicreportAccuracytype() []PublicreportAccuracytype {
	return []PublicreportAccuracytype{
		PublicreportAccuracytypeRooftop,
		PublicreportAccuracytypeParcel,
		PublicreportAccuracytypePoint,
		PublicreportAccuracytypeInterpolated,
		PublicreportAccuracytypeApproximate,
		PublicreportAccuracytypeIntersection,
		PublicreportAccuracytypeCentroid,
		PublicreportAccuracytypeBrowser,
		PublicreportAccuracytypeNone,
	}
}

type PublicreportAccuracytype string

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

func (e PublicreportAccuracytype) Valid() bool {
	switch e {
	case PublicreportAccuracytypeRooftop,
		PublicreportAccuracytypeParcel,
		PublicreportAccuracytypePoint,
		PublicreportAccuracytypeInterpolated,
		PublicreportAccuracytypeApproximate,
		PublicreportAccuracytypeIntersection,
		PublicreportAccuracytypeCentroid,
		PublicreportAccuracytypeBrowser,
		PublicreportAccuracytypeNone:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportAccuracytype 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 PublicreportPermissionaccess
const (
	PublicreportPermissionaccessDenied     PublicreportPermissionaccess = "denied"
	PublicreportPermissionaccessGranted    PublicreportPermissionaccess = "granted"
	PublicreportPermissionaccessUnselected PublicreportPermissionaccess = "unselected"
	PublicreportPermissionaccessWithOwner  PublicreportPermissionaccess = "with-owner"
)

func AllPublicreportPermissionaccess() []PublicreportPermissionaccess {
	return []PublicreportPermissionaccess{
		PublicreportPermissionaccessDenied,
		PublicreportPermissionaccessGranted,
		PublicreportPermissionaccessUnselected,
		PublicreportPermissionaccessWithOwner,
	}
}

type PublicreportPermissionaccess string

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

func (e PublicreportPermissionaccess) Valid() bool {
	switch e {
	case PublicreportPermissionaccessDenied,
		PublicreportPermissionaccessGranted,
		PublicreportPermissionaccessUnselected,
		PublicreportPermissionaccessWithOwner:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

	if !e.Valid() {
		return fmt.Errorf("invalid PublicreportPermissionaccess 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 PublicreportReportlogtype
const (
	PublicreportReportlogtypeCreated      PublicreportReportlogtype = "created"
	PublicreportReportlogtypeInvalidated  PublicreportReportlogtype = "invalidated"
	PublicreportReportlogtypeMessageEmail PublicreportReportlogtype = "message-email"
	PublicreportReportlogtypeMessageText  PublicreportReportlogtype = "message-text"
	PublicreportReportlogtypeReviewed     PublicreportReportlogtype = "reviewed"
	PublicreportReportlogtypeScheduled    PublicreportReportlogtype = "scheduled"
	PublicreportReportlogtypeTreated      PublicreportReportlogtype = "treated"
)

func AllPublicreportReportlogtype() []PublicreportReportlogtype {
	return []PublicreportReportlogtype{
		PublicreportReportlogtypeCreated,
		PublicreportReportlogtypeInvalidated,
		PublicreportReportlogtypeMessageEmail,
		PublicreportReportlogtypeMessageText,
		PublicreportReportlogtypeReviewed,
		PublicreportReportlogtypeScheduled,
		PublicreportReportlogtypeTreated,
	}
}

type PublicreportReportlogtype string

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

func (e PublicreportReportlogtype) Valid() bool {
	switch e {
	case PublicreportReportlogtypeCreated,
		PublicreportReportlogtypeInvalidated,
		PublicreportReportlogtypeMessageEmail,
		PublicreportReportlogtypeMessageText,
		PublicreportReportlogtypeReviewed,
		PublicreportReportlogtypeScheduled,
		PublicreportReportlogtypeTreated:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

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

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

type PublicreportReportstatustype string

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

func (e PublicreportReportstatustype) Valid() bool {
	switch e {
	case PublicreportReportstatustypeReported,
		PublicreportReportstatustypeReviewed,
		PublicreportReportstatustypeScheduled,
		PublicreportReportstatustypeTreated,
		PublicreportReportstatustypeInvalidated:
		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
}

// Enum values for PublicreportReporttype
const (
	PublicreportReporttypeNuisance   PublicreportReporttype = "nuisance"
	PublicreportReporttypeWater      PublicreportReporttype = "water"
	PublicreportReporttypeCompliance PublicreportReporttype = "compliance"
)

func AllPublicreportReporttype() []PublicreportReporttype {
	return []PublicreportReporttype{
		PublicreportReporttypeNuisance,
		PublicreportReporttypeWater,
		PublicreportReporttypeCompliance,
	}
}

type PublicreportReporttype string

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

func (e PublicreportReporttype) Valid() bool {
	switch e {
	case PublicreportReporttypeNuisance,
		PublicreportReporttypeWater,
		PublicreportReporttypeCompliance:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Reviewtaskresolutiontype
const (
	ReviewtaskresolutiontypeCommitted Reviewtaskresolutiontype = "committed"
	ReviewtaskresolutiontypeDiscarded Reviewtaskresolutiontype = "discarded"
)

func AllReviewtaskresolutiontype() []Reviewtaskresolutiontype {
	return []Reviewtaskresolutiontype{
		ReviewtaskresolutiontypeCommitted,
		ReviewtaskresolutiontypeDiscarded,
	}
}

type Reviewtaskresolutiontype string

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

func (e Reviewtaskresolutiontype) Valid() bool {
	switch e {
	case ReviewtaskresolutiontypeCommitted,
		ReviewtaskresolutiontypeDiscarded:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Signaltype
const (
	SignaltypeFlyoverPool             Signaltype = "flyover pool"
	SignaltypePlanFollowup            Signaltype = "plan followup"
	SignaltypePublicreportWater       Signaltype = "publicreport water"
	SignaltypePublicreportNuisance    Signaltype = "publicreport nuisance"
	SignaltypeResidualExiring         Signaltype = "residual exiring"
	SignaltypeSurveillanceObservation Signaltype = "surveillance observation"
	SignaltypeTrapSpike               Signaltype = "trap spike"
)

func AllSignaltype() []Signaltype {
	return []Signaltype{
		SignaltypeFlyoverPool,
		SignaltypePlanFollowup,
		SignaltypePublicreportWater,
		SignaltypePublicreportNuisance,
		SignaltypeResidualExiring,
		SignaltypeSurveillanceObservation,
		SignaltypeTrapSpike,
	}
}

type Signaltype string

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

func (e Signaltype) Valid() bool {
	switch e {
	case SignaltypeFlyoverPool,
		SignaltypePlanFollowup,
		SignaltypePublicreportWater,
		SignaltypePublicreportNuisance,
		SignaltypeResidualExiring,
		SignaltypeSurveillanceObservation,
		SignaltypeTrapSpike:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for Userrole
const (
	UserroleRoot         Userrole = "root"
	UserroleAccountOwner Userrole = "account-owner"
)

func AllUserrole() []Userrole {
	return []Userrole{
		UserroleRoot,
		UserroleAccountOwner,
	}
}

type Userrole string

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

func (e Userrole) Valid() bool {
	switch e {
	case UserroleRoot, UserroleAccountOwner:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}
