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

package webhookdb

import (
	"database/sql/driver"
	"fmt"
	"net/netip"

	"github.com/jackc/pgx/v5/pgtype"
)

type BillingInvoiceStatus string

const (
	BillingInvoiceStatusDraft         BillingInvoiceStatus = "draft"
	BillingInvoiceStatusOpen          BillingInvoiceStatus = "open"
	BillingInvoiceStatusPaid          BillingInvoiceStatus = "paid"
	BillingInvoiceStatusVoid          BillingInvoiceStatus = "void"
	BillingInvoiceStatusUncollectible BillingInvoiceStatus = "uncollectible"
)

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

type NullBillingInvoiceStatus struct {
	BillingInvoiceStatus BillingInvoiceStatus
	Valid                bool // Valid is true if BillingInvoiceStatus is not NULL
}

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

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

type BillingLockReason string

const (
	BillingLockReasonPastDue  BillingLockReason = "past_due"
	BillingLockReasonCanceled BillingLockReason = "canceled"
	BillingLockReasonUnpaid   BillingLockReason = "unpaid"
	BillingLockReasonManual   BillingLockReason = "manual"
)

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

type NullBillingLockReason struct {
	BillingLockReason BillingLockReason
	Valid             bool // Valid is true if BillingLockReason is not NULL
}

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

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

type BillingProvider string

const (
	BillingProviderStripe BillingProvider = "stripe"
)

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

type NullBillingProvider struct {
	BillingProvider BillingProvider
	Valid           bool // Valid is true if BillingProvider is not NULL
}

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

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

type BillingSubscriptionStatus string

const (
	BillingSubscriptionStatusNone       BillingSubscriptionStatus = "none"
	BillingSubscriptionStatusIncomplete BillingSubscriptionStatus = "incomplete"
	BillingSubscriptionStatusTrialing   BillingSubscriptionStatus = "trialing"
	BillingSubscriptionStatusActive     BillingSubscriptionStatus = "active"
	BillingSubscriptionStatusPastDue    BillingSubscriptionStatus = "past_due"
	BillingSubscriptionStatusCanceled   BillingSubscriptionStatus = "canceled"
	BillingSubscriptionStatusUnpaid     BillingSubscriptionStatus = "unpaid"
	BillingSubscriptionStatusPaused     BillingSubscriptionStatus = "paused"
)

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

type NullBillingSubscriptionStatus struct {
	BillingSubscriptionStatus BillingSubscriptionStatus
	Valid                     bool // Valid is true if BillingSubscriptionStatus is not NULL
}

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

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

type CheckConclusion string

const (
	CheckConclusionSuccess        CheckConclusion = "success"
	CheckConclusionFailure        CheckConclusion = "failure"
	CheckConclusionNeutral        CheckConclusion = "neutral"
	CheckConclusionCancelled      CheckConclusion = "cancelled"
	CheckConclusionSkipped        CheckConclusion = "skipped"
	CheckConclusionTimedOut       CheckConclusion = "timed_out"
	CheckConclusionActionRequired CheckConclusion = "action_required"
	CheckConclusionStale          CheckConclusion = "stale"
)

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

type NullCheckConclusion struct {
	CheckConclusion CheckConclusion
	Valid           bool // Valid is true if CheckConclusion is not NULL
}

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

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

type CheckStatus string

const (
	CheckStatusQueued     CheckStatus = "queued"
	CheckStatusInProgress CheckStatus = "in_progress"
	CheckStatusCompleted  CheckStatus = "completed"
	CheckStatusPending    CheckStatus = "pending"
)

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

type NullCheckStatus struct {
	CheckStatus CheckStatus
	Valid       bool // Valid is true if CheckStatus is not NULL
}

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

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

type CollabRole string

const (
	CollabRoleRead     CollabRole = "read"
	CollabRoleTriage   CollabRole = "triage"
	CollabRoleWrite    CollabRole = "write"
	CollabRoleMaintain CollabRole = "maintain"
	CollabRoleAdmin    CollabRole = "admin"
)

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

type NullCollabRole struct {
	CollabRole CollabRole
	Valid      bool // Valid is true if CollabRole is not NULL
}

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

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

type IssueKind string

const (
	IssueKindIssue IssueKind = "issue"
	IssueKindPr    IssueKind = "pr"
)

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

type NullIssueKind struct {
	IssueKind IssueKind
	Valid     bool // Valid is true if IssueKind is not NULL
}

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

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

type IssueRefSource string

const (
	IssueRefSourceCommentBody   IssueRefSource = "comment_body"
	IssueRefSourceIssueBody     IssueRefSource = "issue_body"
	IssueRefSourceCommitMessage IssueRefSource = "commit_message"
)

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

type NullIssueRefSource struct {
	IssueRefSource IssueRefSource
	Valid          bool // Valid is true if IssueRefSource is not NULL
}

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

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

type IssueState string

const (
	IssueStateOpen   IssueState = "open"
	IssueStateClosed IssueState = "closed"
)

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

type NullIssueState struct {
	IssueState IssueState
	Valid      bool // Valid is true if IssueState is not NULL
}

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

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

type IssueStateReason string

const (
	IssueStateReasonCompleted  IssueStateReason = "completed"
	IssueStateReasonNotPlanned IssueStateReason = "not_planned"
	IssueStateReasonReopened   IssueStateReason = "reopened"
	IssueStateReasonDuplicate  IssueStateReason = "duplicate"
)

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

type NullIssueStateReason struct {
	IssueStateReason IssueStateReason
	Valid            bool // Valid is true if IssueStateReason is not NULL
}

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

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

type MilestoneState string

const (
	MilestoneStateOpen   MilestoneState = "open"
	MilestoneStateClosed MilestoneState = "closed"
)

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

type NullMilestoneState struct {
	MilestoneState MilestoneState
	Valid          bool // Valid is true if MilestoneState is not NULL
}

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

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

type NotificationThreadKind string

const (
	NotificationThreadKindIssue NotificationThreadKind = "issue"
	NotificationThreadKindPr    NotificationThreadKind = "pr"
)

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

type NullNotificationThreadKind struct {
	NotificationThreadKind NotificationThreadKind
	Valid                  bool // Valid is true if NotificationThreadKind is not NULL
}

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

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

type OrgPlan string

const (
	OrgPlanFree       OrgPlan = "free"
	OrgPlanTeam       OrgPlan = "team"
	OrgPlanEnterprise OrgPlan = "enterprise"
)

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

type NullOrgPlan struct {
	OrgPlan OrgPlan
	Valid   bool // Valid is true if OrgPlan is not NULL
}

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

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

type OrgRole string

const (
	OrgRoleOwner  OrgRole = "owner"
	OrgRoleMember OrgRole = "member"
)

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

type NullOrgRole struct {
	OrgRole OrgRole
	Valid   bool // Valid is true if OrgRole is not NULL
}

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

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

type PrFileStatus string

const (
	PrFileStatusAdded    PrFileStatus = "added"
	PrFileStatusModified PrFileStatus = "modified"
	PrFileStatusDeleted  PrFileStatus = "deleted"
	PrFileStatusRenamed  PrFileStatus = "renamed"
	PrFileStatusCopied   PrFileStatus = "copied"
)

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

type NullPrFileStatus struct {
	PrFileStatus PrFileStatus
	Valid        bool // Valid is true if PrFileStatus is not NULL
}

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

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

type PrMergeMethod string

const (
	PrMergeMethodMerge  PrMergeMethod = "merge"
	PrMergeMethodSquash PrMergeMethod = "squash"
	PrMergeMethodRebase PrMergeMethod = "rebase"
)

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

type NullPrMergeMethod struct {
	PrMergeMethod PrMergeMethod
	Valid         bool // Valid is true if PrMergeMethod is not NULL
}

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

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

type PrMergeableState string

const (
	PrMergeableStateUnknown PrMergeableState = "unknown"
	PrMergeableStateClean   PrMergeableState = "clean"
	PrMergeableStateDirty   PrMergeableState = "dirty"
	PrMergeableStateBlocked PrMergeableState = "blocked"
	PrMergeableStateBehind  PrMergeableState = "behind"
)

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

type NullPrMergeableState struct {
	PrMergeableState PrMergeableState
	Valid            bool // Valid is true if PrMergeableState is not NULL
}

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

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

type PrReviewSide string

const (
	PrReviewSideLeft  PrReviewSide = "left"
	PrReviewSideRight PrReviewSide = "right"
)

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

type NullPrReviewSide struct {
	PrReviewSide PrReviewSide
	Valid        bool // Valid is true if PrReviewSide is not NULL
}

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

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

type PrReviewState string

const (
	PrReviewStateComment        PrReviewState = "comment"
	PrReviewStateApprove        PrReviewState = "approve"
	PrReviewStateRequestChanges PrReviewState = "request_changes"
)

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

type NullPrReviewState struct {
	PrReviewState PrReviewState
	Valid         bool // Valid is true if PrReviewState is not NULL
}

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

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

type PrincipalKind string

const (
	PrincipalKindUser PrincipalKind = "user"
	PrincipalKindOrg  PrincipalKind = "org"
)

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

type NullPrincipalKind struct {
	PrincipalKind PrincipalKind
	Valid         bool // Valid is true if PrincipalKind is not NULL
}

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

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

type RepoInitStatus string

const (
	RepoInitStatusInitialized RepoInitStatus = "initialized"
	RepoInitStatusInitPending RepoInitStatus = "init_pending"
	RepoInitStatusInitFailed  RepoInitStatus = "init_failed"
)

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

type NullRepoInitStatus struct {
	RepoInitStatus RepoInitStatus
	Valid          bool // Valid is true if RepoInitStatus is not NULL
}

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

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

type RepoVisibility string

const (
	RepoVisibilityPublic  RepoVisibility = "public"
	RepoVisibilityPrivate RepoVisibility = "private"
)

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

type NullRepoVisibility struct {
	RepoVisibility RepoVisibility
	Valid          bool // Valid is true if RepoVisibility is not NULL
}

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

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

type TeamPrivacy string

const (
	TeamPrivacyVisible TeamPrivacy = "visible"
	TeamPrivacySecret  TeamPrivacy = "secret"
)

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

type NullTeamPrivacy struct {
	TeamPrivacy TeamPrivacy
	Valid       bool // Valid is true if TeamPrivacy is not NULL
}

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

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

type TeamRepoRole string

const (
	TeamRepoRoleRead     TeamRepoRole = "read"
	TeamRepoRoleTriage   TeamRepoRole = "triage"
	TeamRepoRoleWrite    TeamRepoRole = "write"
	TeamRepoRoleMaintain TeamRepoRole = "maintain"
	TeamRepoRoleAdmin    TeamRepoRole = "admin"
)

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

type NullTeamRepoRole struct {
	TeamRepoRole TeamRepoRole
	Valid        bool // Valid is true if TeamRepoRole is not NULL
}

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

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

type TeamRole string

const (
	TeamRoleMember     TeamRole = "member"
	TeamRoleMaintainer TeamRole = "maintainer"
)

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

type NullTeamRole struct {
	TeamRole TeamRole
	Valid    bool // Valid is true if TeamRole is not NULL
}

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

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

type TransactionalEmailStatus string

const (
	TransactionalEmailStatusQueued      TransactionalEmailStatus = "queued"
	TransactionalEmailStatusSent        TransactionalEmailStatus = "sent"
	TransactionalEmailStatusSoftBounced TransactionalEmailStatus = "soft_bounced"
	TransactionalEmailStatusHardBounced TransactionalEmailStatus = "hard_bounced"
	TransactionalEmailStatusDropped     TransactionalEmailStatus = "dropped"
)

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

type NullTransactionalEmailStatus struct {
	TransactionalEmailStatus TransactionalEmailStatus
	Valid                    bool // Valid is true if TransactionalEmailStatus is not NULL
}

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

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

type TransferPrincipalKind string

const (
	TransferPrincipalKindUser TransferPrincipalKind = "user"
	TransferPrincipalKindOrg  TransferPrincipalKind = "org"
)

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

type NullTransferPrincipalKind struct {
	TransferPrincipalKind TransferPrincipalKind
	Valid                 bool // Valid is true if TransferPrincipalKind is not NULL
}

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

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

type TransferStatus string

const (
	TransferStatusPending  TransferStatus = "pending"
	TransferStatusAccepted TransferStatus = "accepted"
	TransferStatusDeclined TransferStatus = "declined"
	TransferStatusCanceled TransferStatus = "canceled"
	TransferStatusExpired  TransferStatus = "expired"
)

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

type NullTransferStatus struct {
	TransferStatus TransferStatus
	Valid          bool // Valid is true if TransferStatus is not NULL
}

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

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

type TrendingKind string

const (
	TrendingKindRepos TrendingKind = "repos"
	TrendingKindUsers TrendingKind = "users"
)

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

type NullTrendingKind struct {
	TrendingKind TrendingKind
	Valid        bool // Valid is true if TrendingKind is not NULL
}

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

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

type TrendingScope string

const (
	TrendingScopeDay   TrendingScope = "day"
	TrendingScopeWeek  TrendingScope = "week"
	TrendingScopeMonth TrendingScope = "month"
)

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

type NullTrendingScope struct {
	TrendingScope TrendingScope
	Valid         bool // Valid is true if TrendingScope is not NULL
}

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

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

type WatchLevel string

const (
	WatchLevelAll           WatchLevel = "all"
	WatchLevelParticipating WatchLevel = "participating"
	WatchLevelIgnore        WatchLevel = "ignore"
)

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

type NullWatchLevel struct {
	WatchLevel WatchLevel
	Valid      bool // Valid is true if WatchLevel is not NULL
}

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

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

type WebhookContentType string

const (
	WebhookContentTypeJson WebhookContentType = "json"
	WebhookContentTypeForm WebhookContentType = "form"
)

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

type NullWebhookContentType struct {
	WebhookContentType WebhookContentType
	Valid              bool // Valid is true if WebhookContentType is not NULL
}

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

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

type WebhookDeliveryStatus string

const (
	WebhookDeliveryStatusPending         WebhookDeliveryStatus = "pending"
	WebhookDeliveryStatusSucceeded       WebhookDeliveryStatus = "succeeded"
	WebhookDeliveryStatusFailedRetry     WebhookDeliveryStatus = "failed_retry"
	WebhookDeliveryStatusFailedPermanent WebhookDeliveryStatus = "failed_permanent"
)

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

type NullWebhookDeliveryStatus struct {
	WebhookDeliveryStatus WebhookDeliveryStatus
	Valid                 bool // Valid is true if WebhookDeliveryStatus is not NULL
}

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

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

type WebhookOwnerKind string

const (
	WebhookOwnerKindRepo WebhookOwnerKind = "repo"
	WebhookOwnerKindOrg  WebhookOwnerKind = "org"
)

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

type NullWebhookOwnerKind struct {
	WebhookOwnerKind WebhookOwnerKind
	Valid            bool // Valid is true if WebhookOwnerKind is not NULL
}

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

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

type WorkflowJobStatus string

const (
	WorkflowJobStatusQueued    WorkflowJobStatus = "queued"
	WorkflowJobStatusRunning   WorkflowJobStatus = "running"
	WorkflowJobStatusCompleted WorkflowJobStatus = "completed"
	WorkflowJobStatusCancelled WorkflowJobStatus = "cancelled"
	WorkflowJobStatusSkipped   WorkflowJobStatus = "skipped"
)

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

type NullWorkflowJobStatus struct {
	WorkflowJobStatus WorkflowJobStatus
	Valid             bool // Valid is true if WorkflowJobStatus is not NULL
}

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

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

type WorkflowRunEvent string

const (
	WorkflowRunEventPush             WorkflowRunEvent = "push"
	WorkflowRunEventPullRequest      WorkflowRunEvent = "pull_request"
	WorkflowRunEventSchedule         WorkflowRunEvent = "schedule"
	WorkflowRunEventWorkflowDispatch WorkflowRunEvent = "workflow_dispatch"
)

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

type NullWorkflowRunEvent struct {
	WorkflowRunEvent WorkflowRunEvent
	Valid            bool // Valid is true if WorkflowRunEvent is not NULL
}

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

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

type WorkflowRunStatus string

const (
	WorkflowRunStatusQueued    WorkflowRunStatus = "queued"
	WorkflowRunStatusRunning   WorkflowRunStatus = "running"
	WorkflowRunStatusCompleted WorkflowRunStatus = "completed"
	WorkflowRunStatusCancelled WorkflowRunStatus = "cancelled"
)

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

type NullWorkflowRunStatus struct {
	WorkflowRunStatus WorkflowRunStatus
	Valid             bool // Valid is true if WorkflowRunStatus is not NULL
}

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

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

type WorkflowRunnerStatus string

const (
	WorkflowRunnerStatusIdle    WorkflowRunnerStatus = "idle"
	WorkflowRunnerStatusBusy    WorkflowRunnerStatus = "busy"
	WorkflowRunnerStatusOffline WorkflowRunnerStatus = "offline"
)

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

type NullWorkflowRunnerStatus struct {
	WorkflowRunnerStatus WorkflowRunnerStatus
	Valid                bool // Valid is true if WorkflowRunnerStatus is not NULL
}

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

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

type WorkflowStepStatus string

const (
	WorkflowStepStatusQueued    WorkflowStepStatus = "queued"
	WorkflowStepStatusRunning   WorkflowStepStatus = "running"
	WorkflowStepStatusCompleted WorkflowStepStatus = "completed"
	WorkflowStepStatusCancelled WorkflowStepStatus = "cancelled"
	WorkflowStepStatusSkipped   WorkflowStepStatus = "skipped"
)

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

type NullWorkflowStepStatus struct {
	WorkflowStepStatus WorkflowStepStatus
	Valid              bool // Valid is true if WorkflowStepStatus is not NULL
}

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

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

type ActionsVariable struct {
	ID              int64
	RepoID          pgtype.Int8
	OrgID           pgtype.Int8
	Name            string
	Value           string
	CreatedByUserID pgtype.Int8
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type AuthAuditLog struct {
	ID         int64
	ActorID    pgtype.Int8
	Action     string
	TargetType string
	TargetID   pgtype.Int8
	Meta       []byte
	CreatedAt  pgtype.Timestamptz
}

type AuthThrottle struct {
	ID              int64
	Scope           string
	Identifier      string
	Hits            int32
	WindowStartedAt pgtype.Timestamptz
}

type BillingInvoice struct {
	ID                   int64
	OrgID                int64
	Provider             BillingProvider
	StripeInvoiceID      string
	StripeCustomerID     string
	StripeSubscriptionID pgtype.Text
	Status               BillingInvoiceStatus
	Number               string
	Currency             string
	AmountDueCents       int64
	AmountPaidCents      int64
	AmountRemainingCents int64
	HostedInvoiceUrl     string
	InvoicePdfUrl        string
	PeriodStart          pgtype.Timestamptz
	PeriodEnd            pgtype.Timestamptz
	DueAt                pgtype.Timestamptz
	PaidAt               pgtype.Timestamptz
	VoidedAt             pgtype.Timestamptz
	CreatedAt            pgtype.Timestamptz
	UpdatedAt            pgtype.Timestamptz
}

type BillingSeatSnapshot struct {
	ID                   int64
	OrgID                int64
	Provider             BillingProvider
	StripeSubscriptionID pgtype.Text
	ActiveMembers        int32
	BillableSeats        int32
	Source               string
	CapturedAt           pgtype.Timestamptz
}

type BillingWebhookEvent struct {
	ID                 int64
	Provider           BillingProvider
	ProviderEventID    string
	EventType          string
	ApiVersion         string
	Payload            []byte
	ReceivedAt         pgtype.Timestamptz
	ProcessedAt        pgtype.Timestamptz
	ProcessError       string
	ProcessingAttempts int32
}

type BranchProtectionRule struct {
	ID                             int64
	RepoID                         int64
	Pattern                        string
	PreventForcePush               bool
	PreventDeletion                bool
	RequirePrForPush               bool
	AllowedPusherUserIds           []int64
	RequireSignedCommits           bool
	StatusChecksRequired           []string
	CreatedAt                      pgtype.Timestamptz
	UpdatedAt                      pgtype.Timestamptz
	CreatedByUserID                pgtype.Int8
	RequiredReviewCount            int32
	DismissStaleReviewsOnPush      bool
	RequireCodeOwnerReview         bool
	DismissStaleStatusChecksOnPush bool
}

type CheckRun struct {
	ID          int64
	SuiteID     int64
	RepoID      int64
	HeadSha     string
	Name        string
	Status      CheckStatus
	Conclusion  NullCheckConclusion
	StartedAt   pgtype.Timestamptz
	CompletedAt pgtype.Timestamptz
	DetailsUrl  string
	Output      []byte
	ExternalID  pgtype.Text
	CreatedAt   pgtype.Timestamptz
	UpdatedAt   pgtype.Timestamptz
}

type CheckSuite struct {
	ID         int64
	RepoID     int64
	HeadSha    string
	AppSlug    string
	Status     CheckStatus
	Conclusion NullCheckConclusion
	CreatedAt  pgtype.Timestamptz
	UpdatedAt  pgtype.Timestamptz
}

type CodeSearchContent struct {
	RepoID      int64
	RefName     string
	Path        string
	ContentTsv  interface{}
	ContentTrgm string
}

type CodeSearchPath struct {
	RepoID  int64
	RefName string
	Path    string
	Tsv     interface{}
}

type DomainEvent struct {
	ID          int64
	ActorUserID pgtype.Int8
	Kind        string
	RepoID      pgtype.Int8
	SourceKind  string
	SourceID    int64
	Public      bool
	Payload     []byte
	CreatedAt   pgtype.Timestamptz
}

type DomainEventsProcessed struct {
	Consumer    string
	LastEventID int64
	UpdatedAt   pgtype.Timestamptz
}

type EmailVerification struct {
	ID          int64
	UserEmailID int64
	TokenHash   []byte
	ExpiresAt   pgtype.Timestamptz
	UsedAt      pgtype.Timestamptz
	CreatedAt   pgtype.Timestamptz
}

type Follow struct {
	ID             int64
	FollowerUserID int64
	FolloweeUserID pgtype.Int8
	FolloweeOrgID  pgtype.Int8
	FollowedAt     pgtype.Timestamptz
}

type Issue struct {
	ID                int64
	RepoID            int64
	Number            int64
	Kind              IssueKind
	Title             string
	Body              string
	BodyHtmlCached    pgtype.Text
	MdPipelineVersion int32
	AuthorUserID      pgtype.Int8
	State             IssueState
	StateReason       NullIssueStateReason
	Locked            bool
	LockReason        pgtype.Text
	MilestoneID       pgtype.Int8
	CreatedAt         pgtype.Timestamptz
	UpdatedAt         pgtype.Timestamptz
	EditedAt          pgtype.Timestamptz
	ClosedAt          pgtype.Timestamptz
	ClosedByUserID    pgtype.Int8
}

type IssueAssignee struct {
	IssueID          int64
	UserID           int64
	AssignedAt       pgtype.Timestamptz
	AssignedByUserID pgtype.Int8
}

type IssueComment struct {
	ID                int64
	IssueID           int64
	AuthorUserID      pgtype.Int8
	Body              string
	BodyHtmlCached    pgtype.Text
	MdPipelineVersion int32
	CreatedAt         pgtype.Timestamptz
	UpdatedAt         pgtype.Timestamptz
	EditedAt          pgtype.Timestamptz
}

type IssueEvent struct {
	ID          int64
	IssueID     int64
	ActorUserID pgtype.Int8
	Kind        string
	Meta        []byte
	RefTargetID pgtype.Int8
	CreatedAt   pgtype.Timestamptz
}

type IssueLabel struct {
	IssueID         int64
	LabelID         int64
	AppliedAt       pgtype.Timestamptz
	AppliedByUserID pgtype.Int8
}

type IssueReference struct {
	ID             int64
	SourceIssueID  pgtype.Int8
	TargetIssueID  int64
	SourceKind     IssueRefSource
	SourceObjectID pgtype.Int8
	CreatedAt      pgtype.Timestamptz
}

type IssuesSearch struct {
	IssueID      int64
	RepoID       int64
	Kind         IssueKind
	State        IssueState
	AuthorUserID pgtype.Int8
	Tsv          interface{}
}

type Job struct {
	ID          int64
	Kind        string
	Payload     []byte
	RunAt       pgtype.Timestamptz
	Attempts    int32
	MaxAttempts int32
	LastError   pgtype.Text
	LockedBy    pgtype.Text
	LockedAt    pgtype.Timestamptz
	CompletedAt pgtype.Timestamptz
	FailedAt    pgtype.Timestamptz
	CreatedAt   pgtype.Timestamptz
}

type Label struct {
	ID          int64
	RepoID      int64
	Name        string
	Color       string
	Description string
	CreatedAt   pgtype.Timestamptz
}

type Meta struct {
	Key       string
	Value     []byte
	UpdatedAt pgtype.Timestamptz
}

type Milestone struct {
	ID          int64
	RepoID      int64
	Title       string
	Description string
	State       MilestoneState
	DueOn       pgtype.Timestamptz
	CreatedAt   pgtype.Timestamptz
	ClosedAt    pgtype.Timestamptz
}

type Notification struct {
	ID              int64
	RecipientUserID int64
	Kind            string
	Reason          string
	RepoID          pgtype.Int8
	ThreadKind      NullNotificationThreadKind
	ThreadID        pgtype.Int8
	SourceEventID   pgtype.Int8
	Unread          bool
	LastEventAt     pgtype.Timestamptz
	LastActorUserID pgtype.Int8
	Summary         []byte
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type NotificationEmailLog struct {
	ID              int64
	RecipientUserID int64
	NotificationID  pgtype.Int8
	ThreadKind      NullNotificationThreadKind
	ThreadID        pgtype.Int8
	SentAt          pgtype.Timestamptz
	MessageID       pgtype.Text
}

type NotificationThread struct {
	RecipientUserID int64
	ThreadKind      NotificationThreadKind
	ThreadID        int64
	Subscribed      bool
	Reason          string
	UpdatedAt       pgtype.Timestamptz
}

type Org struct {
	ID                    int64
	Slug                  string
	DisplayName           string
	Description           string
	AvatarObjectKey       pgtype.Text
	Location              string
	Website               string
	BillingEmail          string
	Plan                  OrgPlan
	AllowMemberRepoCreate bool
	CreatedByUserID       pgtype.Int8
	SuspendedAt           pgtype.Timestamptz
	SuspendedReason       pgtype.Text
	DeletedAt             pgtype.Timestamptz
	CreatedAt             pgtype.Timestamptz
	UpdatedAt             pgtype.Timestamptz
}

type OrgBillingState struct {
	OrgID                    int64
	Provider                 BillingProvider
	StripeCustomerID         pgtype.Text
	StripeSubscriptionID     pgtype.Text
	StripeSubscriptionItemID pgtype.Text
	Plan                     OrgPlan
	SubscriptionStatus       BillingSubscriptionStatus
	BillableSeats            int32
	SeatSnapshotAt           pgtype.Timestamptz
	CurrentPeriodStart       pgtype.Timestamptz
	CurrentPeriodEnd         pgtype.Timestamptz
	CancelAtPeriodEnd        bool
	TrialEnd                 pgtype.Timestamptz
	PastDueAt                pgtype.Timestamptz
	CanceledAt               pgtype.Timestamptz
	LockedAt                 pgtype.Timestamptz
	LockReason               NullBillingLockReason
	GraceUntil               pgtype.Timestamptz
	LastWebhookEventID       string
	CreatedAt                pgtype.Timestamptz
	UpdatedAt                pgtype.Timestamptz
}

type OrgGithubImport struct {
	ID                int64
	OrgID             int64
	SourceHost        string
	SourceOrg         string
	RequestedByUserID pgtype.Int8
	Status            string
	IncludePrivate    bool
	TokenPresent      bool
	TokenCiphertext   []byte
	TokenNonce        []byte
	TotalCount        int32
	LastError         pgtype.Text
	StartedAt         pgtype.Timestamptz
	CompletedAt       pgtype.Timestamptz
	CreatedAt         pgtype.Timestamptz
	UpdatedAt         pgtype.Timestamptz
}

type OrgGithubImportRepo struct {
	ID               int64
	ImportID         int64
	GithubID         pgtype.Int8
	SourceFullName   string
	SourceName       string
	TargetName       string
	CloneUrl         string
	Description      string
	DefaultBranch    string
	TargetVisibility RepoVisibility
	IsPrivate        bool
	IsFork           bool
	Status           string
	RepoID           pgtype.Int8
	LastError        pgtype.Text
	StartedAt        pgtype.Timestamptz
	CompletedAt      pgtype.Timestamptz
	CreatedAt        pgtype.Timestamptz
	UpdatedAt        pgtype.Timestamptz
}

type OrgInvitation struct {
	ID              int64
	OrgID           int64
	InvitedByUserID pgtype.Int8
	TargetUserID    pgtype.Int8
	TargetEmail     pgtype.Text
	Role            OrgRole
	TokenHash       []byte
	ExpiresAt       pgtype.Timestamptz
	AcceptedAt      pgtype.Timestamptz
	DeclinedAt      pgtype.Timestamptz
	CanceledAt      pgtype.Timestamptz
	CreatedAt       pgtype.Timestamptz
}

type OrgMember struct {
	OrgID           int64
	UserID          int64
	Role            OrgRole
	InvitedByUserID pgtype.Int8
	JoinedAt        pgtype.Timestamptz
}

type PasswordReset struct {
	ID        int64
	UserID    int64
	TokenHash []byte
	ExpiresAt pgtype.Timestamptz
	UsedAt    pgtype.Timestamptz
	CreatedAt pgtype.Timestamptz
}

type PrReview struct {
	ID                int64
	PrIssueID         int64
	AuthorUserID      pgtype.Int8
	State             PrReviewState
	Body              string
	BodyHtmlCached    pgtype.Text
	SubmittedAt       pgtype.Timestamptz
	DismissedAt       pgtype.Timestamptz
	DismissedByUserID pgtype.Int8
	DismissalReason   string
}

type PrReviewComment struct {
	ID                int64
	PrIssueID         int64
	ReviewID          pgtype.Int8
	AuthorUserID      pgtype.Int8
	FilePath          string
	Side              PrReviewSide
	OriginalCommitSha string
	OriginalLine      int32
	OriginalPosition  int32
	CurrentPosition   pgtype.Int4
	Body              string
	BodyHtmlCached    pgtype.Text
	InReplyToID       pgtype.Int8
	Pending           bool
	ResolvedAt        pgtype.Timestamptz
	ResolvedByUserID  pgtype.Int8
	CreatedAt         pgtype.Timestamptz
	UpdatedAt         pgtype.Timestamptz
	EditedAt          pgtype.Timestamptz
}

type PrReviewRequest struct {
	ID                  int64
	PrIssueID           int64
	RequestedUserID     pgtype.Int8
	RequestedTeamID     pgtype.Int8
	RequestedByUserID   pgtype.Int8
	RequestedAt         pgtype.Timestamptz
	DismissedAt         pgtype.Timestamptz
	SatisfiedByReviewID pgtype.Int8
}

type Principal struct {
	Slug string
	Kind PrincipalKind
	ID   int64
}

type ProfilePin struct {
	SetID    int64
	RepoID   int64
	Position int32
	PinnedAt pgtype.Timestamptz
}

type ProfilePinSet struct {
	ID          int64
	OwnerUserID pgtype.Int8
	OwnerOrgID  pgtype.Int8
	UpdatedAt   pgtype.Timestamptz
}

type PullRequest struct {
	IssueID            int64
	BaseRef            string
	HeadRef            string
	HeadRepoID         int64
	BaseOid            string
	HeadOid            string
	Draft              bool
	Mergeable          pgtype.Bool
	MergeableState     PrMergeableState
	MergeCommitSha     pgtype.Text
	MergedAt           pgtype.Timestamptz
	MergedByUserID     pgtype.Int8
	MergeMethod        NullPrMergeMethod
	BaseOidAtMerge     pgtype.Text
	HeadOidAtMerge     pgtype.Text
	LastSynchronizedAt pgtype.Timestamptz
}

type PullRequestCommit struct {
	PrID           int64
	Sha            string
	Position       int32
	AuthorName     string
	AuthorEmail    string
	CommitterName  string
	CommitterEmail string
	Subject        string
	Body           string
	AuthoredAt     pgtype.Timestamptz
	CommittedAt    pgtype.Timestamptz
}

type PullRequestFile struct {
	PrID      int64
	Path      string
	Status    PrFileStatus
	OldPath   pgtype.Text
	Additions int32
	Deletions int32
	Changes   int32
}

type PushEvent struct {
	ID           int64
	RepoID       int64
	PusherUserID pgtype.Int8
	BeforeSha    string
	AfterSha     string
	Ref          string
	Protocol     string
	RequestID    string
	ProcessedAt  pgtype.Timestamptz
	CreatedAt    pgtype.Timestamptz
}

type RateLimit struct {
	Scope           string
	Key             string
	Hits            int32
	WindowStartedAt pgtype.Timestamptz
}

type Repo struct {
	ID                 int64
	OwnerUserID        pgtype.Int8
	OwnerOrgID         pgtype.Int8
	Name               string
	Description        string
	Visibility         RepoVisibility
	DefaultBranch      string
	IsArchived         bool
	ArchivedAt         pgtype.Timestamptz
	DeletedAt          pgtype.Timestamptz
	DiskUsedBytes      int64
	ForkOfRepoID       pgtype.Int8
	LicenseKey         pgtype.Text
	PrimaryLanguage    pgtype.Text
	HasIssues          bool
	HasPulls           bool
	CreatedAt          pgtype.Timestamptz
	UpdatedAt          pgtype.Timestamptz
	DefaultBranchOid   pgtype.Text
	AllowSquashMerge   bool
	AllowRebaseMerge   bool
	AllowMergeCommit   bool
	DefaultMergeMethod PrMergeMethod
	StarCount          int64
	WatcherCount       int64
	ForkCount          int64
	InitStatus         RepoInitStatus
	LastIndexedOid     pgtype.Text
}

type RepoCollaborator struct {
	RepoID        int64
	UserID        int64
	Role          CollabRole
	AddedAt       pgtype.Timestamptz
	AddedByUserID pgtype.Int8
}

type RepoIssueCounter struct {
	RepoID     int64
	NextNumber int64
}

type RepoRedirect struct {
	OldOwnerUserID pgtype.Int8
	OldOwnerOrgID  pgtype.Int8
	OldName        string
	RepoID         int64
	RedirectedAt   pgtype.Timestamptz
}

type RepoSourceRemote struct {
	RepoID        int64
	RemoteUrl     string
	LastFetchedAt pgtype.Timestamptz
	LastError     pgtype.Text
	CreatedAt     pgtype.Timestamptz
	UpdatedAt     pgtype.Timestamptz
}

type RepoTopic struct {
	RepoID    int64
	Topic     string
	CreatedAt pgtype.Timestamptz
}

type RepoTransferRequest struct {
	ID              int64
	RepoID          int64
	FromUserID      int64
	ToPrincipalKind TransferPrincipalKind
	ToPrincipalID   int64
	CreatedBy       int64
	CreatedAt       pgtype.Timestamptz
	ExpiresAt       pgtype.Timestamptz
	Status          TransferStatus
	AcceptedAt      pgtype.Timestamptz
	DeclinedAt      pgtype.Timestamptz
	CanceledAt      pgtype.Timestamptz
}

type ReposSearch struct {
	RepoID int64
	Tsv    interface{}
}

type RunnerJwtUsed struct {
	Jti       string
	RunnerID  int64
	JobID     int64
	RunID     int64
	RepoID    int64
	ExpiresAt pgtype.Timestamptz
	UsedAt    pgtype.Timestamptz
}

type RunnerToken struct {
	ID        int64
	RunnerID  int64
	TokenHash []byte
	ExpiresAt pgtype.Timestamptz
	RevokedAt pgtype.Timestamptz
	CreatedAt pgtype.Timestamptz
}

type SignupIpThrottle struct {
	Cidr            netip.Addr
	Hits            int32
	WindowStartedAt pgtype.Timestamptz
}

type Star struct {
	UserID    int64
	RepoID    int64
	StarredAt pgtype.Timestamptz
}

type Team struct {
	ID              int64
	OrgID           int64
	Slug            string
	DisplayName     string
	Description     string
	ParentTeamID    pgtype.Int8
	Privacy         TeamPrivacy
	CreatedByUserID pgtype.Int8
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type TeamMember struct {
	TeamID        int64
	UserID        int64
	Role          TeamRole
	AddedByUserID pgtype.Int8
	AddedAt       pgtype.Timestamptz
}

type TeamRepoAccess struct {
	TeamID        int64
	RepoID        int64
	Role          TeamRepoRole
	AddedByUserID pgtype.Int8
	AddedAt       pgtype.Timestamptz
}

type TransactionalEmailLog struct {
	ID              int64
	RecipientUserID pgtype.Int8
	RecipientEmail  string
	Kind            string
	Subject         string
	ProviderID      string
	Status          TransactionalEmailStatus
	ErrorSummary    pgtype.Text
	SentAt          pgtype.Timestamptz
	DeliveredAt     pgtype.Timestamptz
}

type TrendingSnapshot struct {
	ID         int64
	Scope      TrendingScope
	Kind       TrendingKind
	CapturedAt pgtype.Timestamptz
	Payload    []byte
}

type User struct {
	ID                          int64
	Username                    string
	DisplayName                 string
	PrimaryEmailID              pgtype.Int8
	PasswordHash                string
	PasswordAlgo                string
	PasswordUpdatedAt           pgtype.Timestamptz
	EmailVerified               bool
	LastLoginAt                 pgtype.Timestamptz
	SuspendedAt                 pgtype.Timestamptz
	SuspendedReason             pgtype.Text
	DeletedAt                   pgtype.Timestamptz
	CreatedAt                   pgtype.Timestamptz
	UpdatedAt                   pgtype.Timestamptz
	Bio                         string
	Location                    string
	Website                     string
	Company                     string
	Pronouns                    string
	AvatarObjectKey             pgtype.Text
	Theme                       string
	SessionEpoch                int32
	IsSiteAdmin                 bool
	IncludePrivateContributions bool
}

type UserEmail struct {
	ID                    int64
	UserID                int64
	Email                 string
	IsPrimary             bool
	Verified              bool
	VerificationTokenHash []byte
	VerificationSentAt    pgtype.Timestamptz
	VerifiedAt            pgtype.Timestamptz
	CreatedAt             pgtype.Timestamptz
}

type UserNotificationPref struct {
	UserID    int64
	Key       string
	Value     []byte
	UpdatedAt pgtype.Timestamptz
}

type UserRecoveryCode struct {
	ID          int64
	UserID      int64
	CodeHash    []byte
	UsedAt      pgtype.Timestamptz
	GeneratedAt pgtype.Timestamptz
	CreatedAt   pgtype.Timestamptz
}

type UserSshKey struct {
	ID                int64
	UserID            int64
	Title             string
	FingerprintSha256 string
	KeyType           string
	KeyBits           int32
	PublicKey         string
	LastUsedAt        pgtype.Timestamptz
	LastUsedIp        *netip.Addr
	CreatedAt         pgtype.Timestamptz
}

type UserToken struct {
	ID          int64
	UserID      int64
	Name        string
	TokenHash   []byte
	TokenPrefix string
	Scopes      []string
	ExpiresAt   pgtype.Timestamptz
	LastUsedAt  pgtype.Timestamptz
	LastUsedIp  *netip.Addr
	RevokedAt   pgtype.Timestamptz
	CreatedAt   pgtype.Timestamptz
}

type UserTotp struct {
	ID              int64
	UserID          int64
	SecretEncrypted []byte
	SecretNonce     []byte
	ConfirmedAt     pgtype.Timestamptz
	LastUsedCounter int64
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type UsernameRedirect struct {
	OldUsername string
	UserID      int64
	ChangedAt   pgtype.Timestamptz
}

type UsersSearch struct {
	UserID int64
	Tsv    interface{}
}

type Watch struct {
	UserID    int64
	RepoID    int64
	Level     WatchLevel
	UpdatedAt pgtype.Timestamptz
}

type Webhook struct {
	ID                   int64
	OwnerKind            WebhookOwnerKind
	OwnerID              int64
	Url                  string
	ContentType          WebhookContentType
	Events               []string
	SecretCiphertext     []byte
	SecretNonce          []byte
	Active               bool
	SslVerification      bool
	ConsecutiveFailures  int32
	AutoDisableThreshold int32
	DisabledAt           pgtype.Timestamptz
	DisabledReason       pgtype.Text
	LastSuccessAt        pgtype.Timestamptz
	LastFailureAt        pgtype.Timestamptz
	CreatedByUserID      pgtype.Int8
	CreatedAt            pgtype.Timestamptz
	UpdatedAt            pgtype.Timestamptz
}

type WebhookDelivery struct {
	ID                int64
	WebhookID         int64
	EventKind         string
	EventID           pgtype.Int8
	DeliveryUuid      pgtype.UUID
	Payload           []byte
	RequestHeaders    []byte
	RequestBody       []byte
	ResponseStatus    pgtype.Int4
	ResponseHeaders   []byte
	ResponseBody      []byte
	ResponseTruncated bool
	StartedAt         pgtype.Timestamptz
	CompletedAt       pgtype.Timestamptz
	Attempt           int32
	MaxAttempts       int32
	NextRetryAt       pgtype.Timestamptz
	Status            WebhookDeliveryStatus
	IdempotencyKey    string
	ErrorSummary      pgtype.Text
	RedeliverOf       pgtype.Int8
}

type WebhookEventsPending struct {
	ID        int64
	RepoID    int64
	EventKind string
	Payload   []byte
	CreatedAt pgtype.Timestamptz
}

type WorkflowArtifact struct {
	ID        int64
	RunID     int64
	Name      string
	ObjectKey string
	ByteCount int64
	ExpiresAt pgtype.Timestamptz
	CreatedAt pgtype.Timestamptz
}

type WorkflowJob struct {
	ID              int64
	RunID           int64
	JobIndex        int32
	JobKey          string
	JobName         string
	RunsOn          string
	RunnerID        pgtype.Int8
	NeedsJobs       []string
	IfExpr          string
	TimeoutMinutes  int32
	Permissions     []byte
	JobEnv          []byte
	Status          WorkflowJobStatus
	Conclusion      NullCheckConclusion
	CancelRequested bool
	StartedAt       pgtype.Timestamptz
	CompletedAt     pgtype.Timestamptz
	Version         int32
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type WorkflowJobSecretMask struct {
	JobID      int64
	Ciphertext []byte
	Nonce      []byte
	CreatedAt  pgtype.Timestamptz
}

type WorkflowRun struct {
	ID               int64
	RepoID           int64
	RunIndex         int64
	WorkflowFile     string
	WorkflowName     string
	HeadSha          string
	HeadRef          string
	Event            WorkflowRunEvent
	EventPayload     []byte
	ActorUserID      pgtype.Int8
	ParentRunID      pgtype.Int8
	ConcurrencyGroup string
	Status           WorkflowRunStatus
	Conclusion       NullCheckConclusion
	Pinned           bool
	NeedApproval     bool
	ApprovedByUserID pgtype.Int8
	StartedAt        pgtype.Timestamptz
	CompletedAt      pgtype.Timestamptz
	Version          int32
	CreatedAt        pgtype.Timestamptz
	UpdatedAt        pgtype.Timestamptz
	TriggerEventID   string
}

type WorkflowRunner struct {
	ID                 int64
	Name               string
	Labels             []string
	Capacity           int32
	Status             WorkflowRunnerStatus
	LastHeartbeatAt    pgtype.Timestamptz
	RegisteredByUserID pgtype.Int8
	CreatedAt          pgtype.Timestamptz
	UpdatedAt          pgtype.Timestamptz
}

type WorkflowSecret struct {
	ID              int64
	RepoID          pgtype.Int8
	OrgID           pgtype.Int8
	Name            string
	Ciphertext      []byte
	Nonce           []byte
	CreatedByUserID pgtype.Int8
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

type WorkflowStep struct {
	ID               int64
	JobID            int64
	StepIndex        int32
	StepID           string
	StepName         string
	IfExpr           string
	RunCommand       string
	UsesAlias        string
	WorkingDirectory string
	StepEnv          []byte
	ContinueOnError  bool
	Status           WorkflowStepStatus
	Conclusion       NullCheckConclusion
	LogObjectKey     pgtype.Text
	LogByteCount     int64
	StartedAt        pgtype.Timestamptz
	CompletedAt      pgtype.Timestamptz
	Version          int32
	CreatedAt        pgtype.Timestamptz
	UpdatedAt        pgtype.Timestamptz
	StepWith         []byte
}

type WorkflowStepLogChunk struct {
	ID        int64
	StepID    int64
	Seq       int32
	Chunk     []byte
	CreatedAt pgtype.Timestamptz
}