2443 lines
59 KiB
Go
2443 lines
59 KiB
Go
// Code generated by BobGen psql v0.42.5. DO NOT EDIT.
|
|
// This file is meant to be re-generated in place and/or deleted at any time.
|
|
|
|
package enums
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"fmt"
|
|
)
|
|
|
|
// Enum values for 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"
|
|
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 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"
|
|
JobtypeTextRespond Jobtype = "text-respond"
|
|
JobtypeTextSend Jobtype = "text-send"
|
|
)
|
|
|
|
func AllJobtype() []Jobtype {
|
|
return []Jobtype{
|
|
JobtypeAudioTranscode,
|
|
JobtypeCSVCommit,
|
|
JobtypeCSVImport,
|
|
JobtypeLabelStudioAudioCreate,
|
|
JobtypeEmailSend,
|
|
JobtypeTextRespond,
|
|
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,
|
|
JobtypeTextRespond,
|
|
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 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"
|
|
)
|
|
|
|
func AllPublicreportReporttype() []PublicreportReporttype {
|
|
return []PublicreportReporttype{
|
|
PublicreportReporttypeNuisance,
|
|
PublicreportReporttypeWater,
|
|
}
|
|
}
|
|
|
|
type PublicreportReporttype string
|
|
|
|
func (e PublicreportReporttype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e PublicreportReporttype) Valid() bool {
|
|
switch e {
|
|
case PublicreportReporttypeNuisance,
|
|
PublicreportReporttypeWater:
|
|
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
|
|
}
|