// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1

package sqlcgen

import (
	"database/sql/driver"
	"fmt"
)

type AuthProvider string

const (
	AuthProviderGithub AuthProvider = "github"
	AuthProviderGitea  AuthProvider = "gitea"
)

func (e *AuthProvider) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = AuthProvider(s)
	case string:
		*e = AuthProvider(s)
	default:
		return fmt.Errorf("unsupported scan type for AuthProvider: %T", src)
	}
	return nil
}

type NullAuthProvider struct {
	AuthProvider AuthProvider `json:"auth_provider"`
	Valid        bool         `json:"valid"` // Valid is true if AuthProvider is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullAuthProvider) Scan(value interface{}) error {
	if value == nil {
		ns.AuthProvider, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.AuthProvider.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullAuthProvider) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.AuthProvider), nil
}

type DeliveryStatus string

const (
	DeliveryStatusPending DeliveryStatus = "pending"
	DeliveryStatusSuccess DeliveryStatus = "success"
	DeliveryStatusFailed  DeliveryStatus = "failed"
)

func (e *DeliveryStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = DeliveryStatus(s)
	case string:
		*e = DeliveryStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for DeliveryStatus: %T", src)
	}
	return nil
}

type NullDeliveryStatus struct {
	DeliveryStatus DeliveryStatus `json:"delivery_status"`
	Valid          bool           `json:"valid"` // Valid is true if DeliveryStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullDeliveryStatus) Scan(value interface{}) error {
	if value == nil {
		ns.DeliveryStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.DeliveryStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullDeliveryStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.DeliveryStatus), nil
}

type EmailMode string

const (
	EmailModeOff         EmailMode = "off"
	EmailModeInstant     EmailMode = "instant"
	EmailModeDailyDigest EmailMode = "daily_digest"
)

func (e *EmailMode) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = EmailMode(s)
	case string:
		*e = EmailMode(s)
	default:
		return fmt.Errorf("unsupported scan type for EmailMode: %T", src)
	}
	return nil
}

type NullEmailMode struct {
	EmailMode EmailMode `json:"email_mode"`
	Valid     bool      `json:"valid"` // Valid is true if EmailMode is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullEmailMode) Scan(value interface{}) error {
	if value == nil {
		ns.EmailMode, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.EmailMode.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullEmailMode) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.EmailMode), nil
}

type EpicStatus string

const (
	EpicStatusBacklog    EpicStatus = "backlog"
	EpicStatusPlanned    EpicStatus = "planned"
	EpicStatusInProgress EpicStatus = "in_progress"
	EpicStatusCompleted  EpicStatus = "completed"
	EpicStatusCanceled   EpicStatus = "canceled"
)

func (e *EpicStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = EpicStatus(s)
	case string:
		*e = EpicStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for EpicStatus: %T", src)
	}
	return nil
}

type NullEpicStatus struct {
	EpicStatus EpicStatus `json:"epic_status"`
	Valid      bool       `json:"valid"` // Valid is true if EpicStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullEpicStatus) Scan(value interface{}) error {
	if value == nil {
		ns.EpicStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.EpicStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullEpicStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.EpicStatus), nil
}

type IssueStatus string

const (
	IssueStatusBacklog        IssueStatus = "backlog"
	IssueStatusPlanned        IssueStatus = "planned"
	IssueStatusInProgress     IssueStatus = "in_progress"
	IssueStatusReadyForReview IssueStatus = "ready_for_review"
	IssueStatusDone           IssueStatus = "done"
	IssueStatusCanceled       IssueStatus = "canceled"
	IssueStatusDuplicate      IssueStatus = "duplicate"
)

func (e *IssueStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = IssueStatus(s)
	case string:
		*e = IssueStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for IssueStatus: %T", src)
	}
	return nil
}

type NullIssueStatus struct {
	IssueStatus IssueStatus `json:"issue_status"`
	Valid       bool        `json:"valid"` // Valid is true if IssueStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullIssueStatus) Scan(value interface{}) error {
	if value == nil {
		ns.IssueStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.IssueStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullIssueStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.IssueStatus), nil
}

type JobStatus string

const (
	JobStatusPending JobStatus = "pending"
	JobStatusRunning JobStatus = "running"
	JobStatusDone    JobStatus = "done"
	JobStatusFailed  JobStatus = "failed"
	JobStatusDead    JobStatus = "dead"
)

func (e *JobStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = JobStatus(s)
	case string:
		*e = JobStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for JobStatus: %T", src)
	}
	return nil
}

type NullJobStatus struct {
	JobStatus JobStatus `json:"job_status"`
	Valid     bool      `json:"valid"` // Valid is true if JobStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullJobStatus) Scan(value interface{}) error {
	if value == nil {
		ns.JobStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.JobStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullJobStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.JobStatus), nil
}

type MemberRole string

const (
	MemberRoleOwner  MemberRole = "owner"
	MemberRoleMember MemberRole = "member"
)

func (e *MemberRole) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = MemberRole(s)
	case string:
		*e = MemberRole(s)
	default:
		return fmt.Errorf("unsupported scan type for MemberRole: %T", src)
	}
	return nil
}

type NullMemberRole struct {
	MemberRole MemberRole `json:"member_role"`
	Valid      bool       `json:"valid"` // Valid is true if MemberRole is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullMemberRole) Scan(value interface{}) error {
	if value == nil {
		ns.MemberRole, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.MemberRole.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullMemberRole) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.MemberRole), nil
}

type Priority string

const (
	PriorityLow     Priority = "low"
	PriorityMedium  Priority = "medium"
	PriorityHigh    Priority = "high"
	PriorityUrgent  Priority = "urgent"
	PriorityFrantic Priority = "frantic"
)

func (e *Priority) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = Priority(s)
	case string:
		*e = Priority(s)
	default:
		return fmt.Errorf("unsupported scan type for Priority: %T", src)
	}
	return nil
}

type NullPriority struct {
	Priority Priority `json:"priority"`
	Valid    bool     `json:"valid"` // Valid is true if Priority is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullPriority) Scan(value interface{}) error {
	if value == nil {
		ns.Priority, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.Priority.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullPriority) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.Priority), nil
}

type ProjectStatus string

const (
	ProjectStatusBacklog    ProjectStatus = "backlog"
	ProjectStatusPlanned    ProjectStatus = "planned"
	ProjectStatusInProgress ProjectStatus = "in_progress"
	ProjectStatusCompleted  ProjectStatus = "completed"
	ProjectStatusCanceled   ProjectStatus = "canceled"
)

func (e *ProjectStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = ProjectStatus(s)
	case string:
		*e = ProjectStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for ProjectStatus: %T", src)
	}
	return nil
}

type NullProjectStatus struct {
	ProjectStatus ProjectStatus `json:"project_status"`
	Valid         bool          `json:"valid"` // Valid is true if ProjectStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullProjectStatus) Scan(value interface{}) error {
	if value == nil {
		ns.ProjectStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.ProjectStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullProjectStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.ProjectStatus), nil
}

type ReceiptStatus string

const (
	ReceiptStatusPending   ReceiptStatus = "pending"
	ReceiptStatusProcessed ReceiptStatus = "processed"
	ReceiptStatusFailed    ReceiptStatus = "failed"
	ReceiptStatusIgnored   ReceiptStatus = "ignored"
)

func (e *ReceiptStatus) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = ReceiptStatus(s)
	case string:
		*e = ReceiptStatus(s)
	default:
		return fmt.Errorf("unsupported scan type for ReceiptStatus: %T", src)
	}
	return nil
}

type NullReceiptStatus struct {
	ReceiptStatus ReceiptStatus `json:"receipt_status"`
	Valid         bool          `json:"valid"` // Valid is true if ReceiptStatus is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullReceiptStatus) Scan(value interface{}) error {
	if value == nil {
		ns.ReceiptStatus, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.ReceiptStatus.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullReceiptStatus) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.ReceiptStatus), nil
}

type ResourceKind string

const (
	ResourceKindProject    ResourceKind = "project"
	ResourceKindIssue      ResourceKind = "issue"
	ResourceKindEpic       ResourceKind = "epic"
	ResourceKindComment    ResourceKind = "comment"
	ResourceKindWikiPage   ResourceKind = "wiki_page"
	ResourceKindUser       ResourceKind = "user"
	ResourceKindLabel      ResourceKind = "label"
	ResourceKindAttachment ResourceKind = "attachment"
	ResourceKindLink       ResourceKind = "link"
	ResourceKindMember     ResourceKind = "member"
	ResourceKindWebhook    ResourceKind = "webhook"
	ResourceKindAuth       ResourceKind = "auth"
)

func (e *ResourceKind) Scan(src interface{}) error {
	switch s := src.(type) {
	case []byte:
		*e = ResourceKind(s)
	case string:
		*e = ResourceKind(s)
	default:
		return fmt.Errorf("unsupported scan type for ResourceKind: %T", src)
	}
	return nil
}

type NullResourceKind struct {
	ResourceKind ResourceKind `json:"resource_kind"`
	Valid        bool         `json:"valid"` // Valid is true if ResourceKind is not NULL
}

// Scan implements the Scanner interface.
func (ns *NullResourceKind) Scan(value interface{}) error {
	if value == nil {
		ns.ResourceKind, ns.Valid = "", false
		return nil
	}
	ns.Valid = true
	return ns.ResourceKind.Scan(value)
}

// Value implements the driver Valuer interface.
func (ns NullResourceKind) Value() (driver.Value, error) {
	if !ns.Valid {
		return nil, nil
	}
	return string(ns.ResourceKind), nil
}