// 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 ArcgisFieldtype
const (
	ArcgisFieldtypeEsrifieldtypesmallinteger ArcgisFieldtype = "esriFieldTypeSmallInteger"
	ArcgisFieldtypeEsrifieldtypeinteger      ArcgisFieldtype = "esriFieldTypeInteger"
	ArcgisFieldtypeEsrifieldtypesingle       ArcgisFieldtype = "esriFieldTypeSingle"
	ArcgisFieldtypeEsrifieldtypedouble       ArcgisFieldtype = "esriFieldTypeDouble"
	ArcgisFieldtypeEsrifieldtypestring       ArcgisFieldtype = "esriFieldTypeString"
	ArcgisFieldtypeEsrifieldtypedate         ArcgisFieldtype = "esriFieldTypeDate"
	ArcgisFieldtypeEsrifieldtypeoid          ArcgisFieldtype = "esriFieldTypeOID"
	ArcgisFieldtypeEsrifieldtypegeometry     ArcgisFieldtype = "esriFieldTypeGeometry"
	ArcgisFieldtypeEsrifieldtypeblob         ArcgisFieldtype = "esriFieldTypeBlob"
	ArcgisFieldtypeEsrifieldtyperaster       ArcgisFieldtype = "esriFieldTypeRaster"
	ArcgisFieldtypeEsrifieldtypeguid         ArcgisFieldtype = "esriFieldTypeGUID"
	ArcgisFieldtypeEsrifieldtypeglobalid     ArcgisFieldtype = "esriFieldTypeGlobalID"
	ArcgisFieldtypeEsrifieldtypexml          ArcgisFieldtype = "esriFieldTypeXML"
	ArcgisFieldtypeEsrifieldtypebiginteger   ArcgisFieldtype = "esriFieldTypeBigInteger"
)

func AllArcgisFieldtype() []ArcgisFieldtype {
	return []ArcgisFieldtype{
		ArcgisFieldtypeEsrifieldtypesmallinteger,
		ArcgisFieldtypeEsrifieldtypeinteger,
		ArcgisFieldtypeEsrifieldtypesingle,
		ArcgisFieldtypeEsrifieldtypedouble,
		ArcgisFieldtypeEsrifieldtypestring,
		ArcgisFieldtypeEsrifieldtypedate,
		ArcgisFieldtypeEsrifieldtypeoid,
		ArcgisFieldtypeEsrifieldtypegeometry,
		ArcgisFieldtypeEsrifieldtypeblob,
		ArcgisFieldtypeEsrifieldtyperaster,
		ArcgisFieldtypeEsrifieldtypeguid,
		ArcgisFieldtypeEsrifieldtypeglobalid,
		ArcgisFieldtypeEsrifieldtypexml,
		ArcgisFieldtypeEsrifieldtypebiginteger,
	}
}

type ArcgisFieldtype string

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

func (e ArcgisFieldtype) Valid() bool {
	switch e {
	case ArcgisFieldtypeEsrifieldtypesmallinteger,
		ArcgisFieldtypeEsrifieldtypeinteger,
		ArcgisFieldtypeEsrifieldtypesingle,
		ArcgisFieldtypeEsrifieldtypedouble,
		ArcgisFieldtypeEsrifieldtypestring,
		ArcgisFieldtypeEsrifieldtypedate,
		ArcgisFieldtypeEsrifieldtypeoid,
		ArcgisFieldtypeEsrifieldtypegeometry,
		ArcgisFieldtypeEsrifieldtypeblob,
		ArcgisFieldtypeEsrifieldtyperaster,
		ArcgisFieldtypeEsrifieldtypeguid,
		ArcgisFieldtypeEsrifieldtypeglobalid,
		ArcgisFieldtypeEsrifieldtypexml,
		ArcgisFieldtypeEsrifieldtypebiginteger:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for ArcgisMappingdestinationaddress
const (
	ArcgisMappingdestinationaddressCountry    ArcgisMappingdestinationaddress = "country"
	ArcgisMappingdestinationaddressLocality   ArcgisMappingdestinationaddress = "locality"
	ArcgisMappingdestinationaddressPostalCode ArcgisMappingdestinationaddress = "postal_code"
	ArcgisMappingdestinationaddressStreet     ArcgisMappingdestinationaddress = "street"
	ArcgisMappingdestinationaddressUnit       ArcgisMappingdestinationaddress = "unit"
)

func AllArcgisMappingdestinationaddress() []ArcgisMappingdestinationaddress {
	return []ArcgisMappingdestinationaddress{
		ArcgisMappingdestinationaddressCountry,
		ArcgisMappingdestinationaddressLocality,
		ArcgisMappingdestinationaddressPostalCode,
		ArcgisMappingdestinationaddressStreet,
		ArcgisMappingdestinationaddressUnit,
	}
}

type ArcgisMappingdestinationaddress string

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

func (e ArcgisMappingdestinationaddress) Valid() bool {
	switch e {
	case ArcgisMappingdestinationaddressCountry,
		ArcgisMappingdestinationaddressLocality,
		ArcgisMappingdestinationaddressPostalCode,
		ArcgisMappingdestinationaddressStreet,
		ArcgisMappingdestinationaddressUnit:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// Enum values for ArcgisMappingdestinationparcel
const (
	ArcgisMappingdestinationparcelApn         ArcgisMappingdestinationparcel = "apn"
	ArcgisMappingdestinationparcelDescription ArcgisMappingdestinationparcel = "description"
)

func AllArcgisMappingdestinationparcel() []ArcgisMappingdestinationparcel {
	return []ArcgisMappingdestinationparcel{
		ArcgisMappingdestinationparcelApn,
		ArcgisMappingdestinationparcelDescription,
	}
}

type ArcgisMappingdestinationparcel string

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

func (e ArcgisMappingdestinationparcel) Valid() bool {
	switch e {
	case ArcgisMappingdestinationparcelApn,
		ArcgisMappingdestinationparcelDescription:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

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

	return nil
}

// 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"
)

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 Countrytype
const (
	CountrytypeUsa Countrytype = "usa"
)

func AllCountrytype() []Countrytype {
	return []Countrytype{
		CountrytypeUsa,
	}
}

type Countrytype string

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

func (e Countrytype) Valid() bool {
	switch e {
	case CountrytypeUsa:
		return true
	default:
		return false
	}
}

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

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

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

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

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

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

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

	if !e.Valid() {
		return fmt.Errorf("invalid Countrytype 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"
	JobtypeTextSend               Jobtype = "text-send"
)

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

type Jobtype string

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

func (e Jobtype) Valid() bool {
	switch e {
	case JobtypeAudioTranscode,
		JobtypeCSVCommit,
		JobtypeCSVImport,
		JobtypeLabelStudioAudioCreate,
		JobtypeEmailSend,
		JobtypeTextSend:
		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 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"
	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 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
}