1439 lines
35 KiB
Go
1439 lines
35 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 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 FileuploadCsvtype
|
|
const (
|
|
FileuploadCsvtypePoollist FileuploadCsvtype = "PoolList"
|
|
)
|
|
|
|
func AllFileuploadCsvtype() []FileuploadCsvtype {
|
|
return []FileuploadCsvtype{
|
|
FileuploadCsvtypePoollist,
|
|
}
|
|
}
|
|
|
|
type FileuploadCsvtype string
|
|
|
|
func (e FileuploadCsvtype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e FileuploadCsvtype) Valid() bool {
|
|
switch e {
|
|
case FileuploadCsvtypePoollist:
|
|
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"
|
|
)
|
|
|
|
func AllFileuploadFilestatustype() []FileuploadFilestatustype {
|
|
return []FileuploadFilestatustype{
|
|
FileuploadFilestatustypeError,
|
|
FileuploadFilestatustypeParsed,
|
|
FileuploadFilestatustypeUploaded,
|
|
}
|
|
}
|
|
|
|
type FileuploadFilestatustype string
|
|
|
|
func (e FileuploadFilestatustype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e FileuploadFilestatustype) Valid() bool {
|
|
switch e {
|
|
case FileuploadFilestatustypeError,
|
|
FileuploadFilestatustypeParsed,
|
|
FileuploadFilestatustypeUploaded:
|
|
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 FileuploadPoolconditiontype
|
|
const (
|
|
FileuploadPoolconditiontypeGreen FileuploadPoolconditiontype = "green"
|
|
FileuploadPoolconditiontypeMurky FileuploadPoolconditiontype = "murky"
|
|
FileuploadPoolconditiontypeBlue FileuploadPoolconditiontype = "blue"
|
|
FileuploadPoolconditiontypeEmpty FileuploadPoolconditiontype = "empty"
|
|
FileuploadPoolconditiontypeUnknown FileuploadPoolconditiontype = "unknown"
|
|
)
|
|
|
|
func AllFileuploadPoolconditiontype() []FileuploadPoolconditiontype {
|
|
return []FileuploadPoolconditiontype{
|
|
FileuploadPoolconditiontypeGreen,
|
|
FileuploadPoolconditiontypeMurky,
|
|
FileuploadPoolconditiontypeBlue,
|
|
FileuploadPoolconditiontypeEmpty,
|
|
FileuploadPoolconditiontypeUnknown,
|
|
}
|
|
}
|
|
|
|
type FileuploadPoolconditiontype string
|
|
|
|
func (e FileuploadPoolconditiontype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e FileuploadPoolconditiontype) Valid() bool {
|
|
switch e {
|
|
case FileuploadPoolconditiontypeGreen,
|
|
FileuploadPoolconditiontypeMurky,
|
|
FileuploadPoolconditiontypeBlue,
|
|
FileuploadPoolconditiontypeEmpty,
|
|
FileuploadPoolconditiontypeUnknown:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e FileuploadPoolconditiontype) All() []FileuploadPoolconditiontype {
|
|
return AllFileuploadPoolconditiontype()
|
|
}
|
|
|
|
func (e FileuploadPoolconditiontype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *FileuploadPoolconditiontype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e FileuploadPoolconditiontype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *FileuploadPoolconditiontype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e FileuploadPoolconditiontype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *FileuploadPoolconditiontype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = FileuploadPoolconditiontype(x)
|
|
case []byte:
|
|
*e = FileuploadPoolconditiontype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into FileuploadPoolconditiontype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid FileuploadPoolconditiontype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enum values for H3aggregationtype
|
|
const (
|
|
H3aggregationtypeMosquitosource H3aggregationtype = "MosquitoSource"
|
|
H3aggregationtypeServicerequest H3aggregationtype = "ServiceRequest"
|
|
H3aggregationtypeTrap H3aggregationtype = "Trap"
|
|
)
|
|
|
|
func AllH3aggregationtype() []H3aggregationtype {
|
|
return []H3aggregationtype{
|
|
H3aggregationtypeMosquitosource,
|
|
H3aggregationtypeServicerequest,
|
|
H3aggregationtypeTrap,
|
|
}
|
|
}
|
|
|
|
type H3aggregationtype string
|
|
|
|
func (e H3aggregationtype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e H3aggregationtype) Valid() bool {
|
|
switch e {
|
|
case H3aggregationtypeMosquitosource,
|
|
H3aggregationtypeServicerequest,
|
|
H3aggregationtypeTrap:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e H3aggregationtype) All() []H3aggregationtype {
|
|
return AllH3aggregationtype()
|
|
}
|
|
|
|
func (e H3aggregationtype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *H3aggregationtype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e H3aggregationtype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *H3aggregationtype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e H3aggregationtype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *H3aggregationtype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = H3aggregationtype(x)
|
|
case []byte:
|
|
*e = H3aggregationtype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into H3aggregationtype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid H3aggregationtype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enum values for Hashtype
|
|
const (
|
|
HashtypeBcrypt14 Hashtype = "bcrypt-14"
|
|
)
|
|
|
|
func AllHashtype() []Hashtype {
|
|
return []Hashtype{
|
|
HashtypeBcrypt14,
|
|
}
|
|
}
|
|
|
|
type Hashtype string
|
|
|
|
func (e Hashtype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e Hashtype) Valid() bool {
|
|
switch e {
|
|
case HashtypeBcrypt14:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e Hashtype) All() []Hashtype {
|
|
return AllHashtype()
|
|
}
|
|
|
|
func (e Hashtype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Hashtype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e Hashtype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Hashtype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e Hashtype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *Hashtype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = Hashtype(x)
|
|
case []byte:
|
|
*e = Hashtype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into Hashtype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid Hashtype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enum values for Imagedatatype
|
|
const (
|
|
ImagedatatypeRaw Imagedatatype = "raw"
|
|
ImagedatatypePNG Imagedatatype = "png"
|
|
)
|
|
|
|
func AllImagedatatype() []Imagedatatype {
|
|
return []Imagedatatype{
|
|
ImagedatatypeRaw,
|
|
ImagedatatypePNG,
|
|
}
|
|
}
|
|
|
|
type Imagedatatype string
|
|
|
|
func (e Imagedatatype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e Imagedatatype) Valid() bool {
|
|
switch e {
|
|
case ImagedatatypeRaw, ImagedatatypePNG:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e Imagedatatype) All() []Imagedatatype {
|
|
return AllImagedatatype()
|
|
}
|
|
|
|
func (e Imagedatatype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Imagedatatype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e Imagedatatype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Imagedatatype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e Imagedatatype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *Imagedatatype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = Imagedatatype(x)
|
|
case []byte:
|
|
*e = Imagedatatype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into Imagedatatype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid Imagedatatype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enum values for Notificationtype
|
|
const (
|
|
NotificationtypeOauthTokenInvalidated Notificationtype = "oauth_token_invalidated"
|
|
)
|
|
|
|
func AllNotificationtype() []Notificationtype {
|
|
return []Notificationtype{
|
|
NotificationtypeOauthTokenInvalidated,
|
|
}
|
|
}
|
|
|
|
type Notificationtype string
|
|
|
|
func (e Notificationtype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e Notificationtype) Valid() bool {
|
|
switch e {
|
|
case NotificationtypeOauthTokenInvalidated:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e Notificationtype) All() []Notificationtype {
|
|
return AllNotificationtype()
|
|
}
|
|
|
|
func (e Notificationtype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Notificationtype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e Notificationtype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *Notificationtype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e Notificationtype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *Notificationtype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = Notificationtype(x)
|
|
case []byte:
|
|
*e = Notificationtype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into Notificationtype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid Notificationtype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
// Enum values for PublicreportAccuracytype
|
|
const (
|
|
PublicreportAccuracytypeRooftop PublicreportAccuracytype = "rooftop"
|
|
PublicreportAccuracytypeParcel PublicreportAccuracytype = "parcel"
|
|
PublicreportAccuracytypePoint PublicreportAccuracytype = "point"
|
|
PublicreportAccuracytypeInterpolated PublicreportAccuracytype = "interpolated"
|
|
PublicreportAccuracytypeApproximate PublicreportAccuracytype = "approximate"
|
|
PublicreportAccuracytypeIntersection PublicreportAccuracytype = "intersection"
|
|
PublicreportAccuracytypeBrowser PublicreportAccuracytype = "browser"
|
|
PublicreportAccuracytypeNone PublicreportAccuracytype = "none"
|
|
)
|
|
|
|
func AllPublicreportAccuracytype() []PublicreportAccuracytype {
|
|
return []PublicreportAccuracytype{
|
|
PublicreportAccuracytypeRooftop,
|
|
PublicreportAccuracytypeParcel,
|
|
PublicreportAccuracytypePoint,
|
|
PublicreportAccuracytypeInterpolated,
|
|
PublicreportAccuracytypeApproximate,
|
|
PublicreportAccuracytypeIntersection,
|
|
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,
|
|
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"
|
|
)
|
|
|
|
func AllPublicreportReportstatustype() []PublicreportReportstatustype {
|
|
return []PublicreportReportstatustype{
|
|
PublicreportReportstatustypeReported,
|
|
PublicreportReportstatustypeReviewed,
|
|
PublicreportReportstatustypeScheduled,
|
|
PublicreportReportstatustypeTreated,
|
|
}
|
|
}
|
|
|
|
type PublicreportReportstatustype string
|
|
|
|
func (e PublicreportReportstatustype) String() string {
|
|
return string(e)
|
|
}
|
|
|
|
func (e PublicreportReportstatustype) Valid() bool {
|
|
switch e {
|
|
case PublicreportReportstatustypeReported,
|
|
PublicreportReportstatustypeReviewed,
|
|
PublicreportReportstatustypeScheduled,
|
|
PublicreportReportstatustypeTreated:
|
|
return true
|
|
default:
|
|
return false
|
|
}
|
|
}
|
|
|
|
// useful when testing in other packages
|
|
func (e PublicreportReportstatustype) All() []PublicreportReportstatustype {
|
|
return AllPublicreportReportstatustype()
|
|
}
|
|
|
|
func (e PublicreportReportstatustype) MarshalText() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *PublicreportReportstatustype) UnmarshalText(text []byte) error {
|
|
return e.Scan(text)
|
|
}
|
|
|
|
func (e PublicreportReportstatustype) MarshalBinary() ([]byte, error) {
|
|
return []byte(e), nil
|
|
}
|
|
|
|
func (e *PublicreportReportstatustype) UnmarshalBinary(data []byte) error {
|
|
return e.Scan(data)
|
|
}
|
|
|
|
func (e PublicreportReportstatustype) Value() (driver.Value, error) {
|
|
return string(e), nil
|
|
}
|
|
|
|
func (e *PublicreportReportstatustype) Scan(value any) error {
|
|
switch x := value.(type) {
|
|
case string:
|
|
*e = PublicreportReportstatustype(x)
|
|
case []byte:
|
|
*e = PublicreportReportstatustype(x)
|
|
case nil:
|
|
return fmt.Errorf("cannot nil into PublicreportReportstatustype")
|
|
default:
|
|
return fmt.Errorf("cannot scan type %T: %v", value, value)
|
|
}
|
|
|
|
if !e.Valid() {
|
|
return fmt.Errorf("invalid PublicreportReportstatustype value: %s", *e)
|
|
}
|
|
|
|
return nil
|
|
}
|