Eli Ribble
2538638c9d
This refactor was born out of the inter-dependency cycles developing between the "background" module and just about every other module which was caused by the background module becoming a dependency of every module that needed to background work and the fact that the background module was also supposedly responsible for the logic for processing those tasks. Instead the "background" module is now very, very shallow and relies entirely on the Postgres NOTIFY logic for triggering jobs. There's a new table, `job` which holds just a type and single row ID. All told, this means that jobs can be added to the queue as part of the API-level or platform-level transaction, ensuring atomicity, and processing coordination is handled by the platform module, which can depend on anything.
2276 lines
54 KiB
Go
2276 lines
54 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"
|
|
)
|
|
|
|
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
|
|
}
|