// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.27.0

package database

import (

"database/sql"

"database/sql/driver"

"encoding/json"

"fmt"

"time"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/sqlc-dev/pqtype"

)

type APIKeyScope string

const (

APIKeyScopeAll APIKeyScope = "all"

APIKeyScopeApplicationConnect APIKeyScope = "application_connect"

)

func (e *APIKeyScope) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = APIKeyScope(s)

case string:

*e = APIKeyScope(s)

default:

return fmt.Errorf("unsupported scan type for APIKeyScope: %T", src)

}

return nil

}

type NullAPIKeyScope struct {

APIKeyScope APIKeyScope `json:"api_key_scope"`

Valid bool `json:"valid"` // Valid is true if APIKeyScope is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullAPIKeyScope) Scan(value interface{}) error {

if value == nil {

ns.APIKeyScope, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.APIKeyScope.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullAPIKeyScope) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.APIKeyScope), nil

}

func (e APIKeyScope) Valid() bool {

switch e {

case APIKeyScopeAll,

APIKeyScopeApplicationConnect:

return true

}

return false

}

func AllAPIKeyScopeValues() []APIKeyScope {

return []APIKeyScope{

APIKeyScopeAll,

APIKeyScopeApplicationConnect,

}

}

type AppSharingLevel string

const (

AppSharingLevelOwner AppSharingLevel = "owner"

AppSharingLevelAuthenticated AppSharingLevel = "authenticated"

AppSharingLevelPublic AppSharingLevel = "public"

)

func (e *AppSharingLevel) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = AppSharingLevel(s)

case string:

*e = AppSharingLevel(s)

default:

return fmt.Errorf("unsupported scan type for AppSharingLevel: %T", src)

}

return nil

}

type NullAppSharingLevel struct {

AppSharingLevel AppSharingLevel `json:"app_sharing_level"`

Valid bool `json:"valid"` // Valid is true if AppSharingLevel is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullAppSharingLevel) Scan(value interface{}) error {

if value == nil {

ns.AppSharingLevel, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.AppSharingLevel.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullAppSharingLevel) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.AppSharingLevel), nil

}

func (e AppSharingLevel) Valid() bool {

switch e {

case AppSharingLevelOwner,

AppSharingLevelAuthenticated,

AppSharingLevelPublic:

return true

}

return false

}

func AllAppSharingLevelValues() []AppSharingLevel {

return []AppSharingLevel{

AppSharingLevelOwner,

AppSharingLevelAuthenticated,

AppSharingLevelPublic,

}

}

type AuditAction string

const (

AuditActionCreate AuditAction = "create"

AuditActionWrite AuditAction = "write"

AuditActionDelete AuditAction = "delete"

AuditActionStart AuditAction = "start"

AuditActionStop AuditAction = "stop"

AuditActionLogin AuditAction = "login"

AuditActionLogout AuditAction = "logout"

AuditActionRegister AuditAction = "register"

AuditActionRequestPasswordReset AuditAction = "request_password_reset"

)

func (e *AuditAction) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = AuditAction(s)

case string:

*e = AuditAction(s)

default:

return fmt.Errorf("unsupported scan type for AuditAction: %T", src)

}

return nil

}

type NullAuditAction struct {

AuditAction AuditAction `json:"audit_action"`

Valid bool `json:"valid"` // Valid is true if AuditAction is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullAuditAction) Scan(value interface{}) error {

if value == nil {

ns.AuditAction, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.AuditAction.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullAuditAction) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.AuditAction), nil

}

func (e AuditAction) Valid() bool {

switch e {

case AuditActionCreate,

AuditActionWrite,

AuditActionDelete,

AuditActionStart,

AuditActionStop,

AuditActionLogin,

AuditActionLogout,

AuditActionRegister,

AuditActionRequestPasswordReset:

return true

}

return false

}

func AllAuditActionValues() []AuditAction {

return []AuditAction{

AuditActionCreate,

AuditActionWrite,

AuditActionDelete,

AuditActionStart,

AuditActionStop,

AuditActionLogin,

AuditActionLogout,

AuditActionRegister,

AuditActionRequestPasswordReset,

}

}

type AutomaticUpdates string

const (

AutomaticUpdatesAlways AutomaticUpdates = "always"

AutomaticUpdatesNever AutomaticUpdates = "never"

)

func (e *AutomaticUpdates) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = AutomaticUpdates(s)

case string:

*e = AutomaticUpdates(s)

default:

return fmt.Errorf("unsupported scan type for AutomaticUpdates: %T", src)

}

return nil

}

type NullAutomaticUpdates struct {

AutomaticUpdates AutomaticUpdates `json:"automatic_updates"`

Valid bool `json:"valid"` // Valid is true if AutomaticUpdates is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullAutomaticUpdates) Scan(value interface{}) error {

if value == nil {

ns.AutomaticUpdates, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.AutomaticUpdates.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullAutomaticUpdates) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.AutomaticUpdates), nil

}

func (e AutomaticUpdates) Valid() bool {

switch e {

case AutomaticUpdatesAlways,

AutomaticUpdatesNever:

return true

}

return false

}

func AllAutomaticUpdatesValues() []AutomaticUpdates {

return []AutomaticUpdates{

AutomaticUpdatesAlways,

AutomaticUpdatesNever,

}

}

type BuildReason string

const (

BuildReasonInitiator BuildReason = "initiator"

BuildReasonAutostart BuildReason = "autostart"

BuildReasonAutostop BuildReason = "autostop"

BuildReasonDormancy BuildReason = "dormancy"

BuildReasonFailedstop BuildReason = "failedstop"

BuildReasonAutodelete BuildReason = "autodelete"

)

func (e *BuildReason) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = BuildReason(s)

case string:

*e = BuildReason(s)

default:

return fmt.Errorf("unsupported scan type for BuildReason: %T", src)

}

return nil

}

type NullBuildReason struct {

BuildReason BuildReason `json:"build_reason"`

Valid bool `json:"valid"` // Valid is true if BuildReason is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullBuildReason) Scan(value interface{}) error {

if value == nil {

ns.BuildReason, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.BuildReason.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullBuildReason) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.BuildReason), nil

}

func (e BuildReason) Valid() bool {

switch e {

case BuildReasonInitiator,

BuildReasonAutostart,

BuildReasonAutostop,

BuildReasonDormancy,

BuildReasonFailedstop,

BuildReasonAutodelete:

return true

}

return false

}

func AllBuildReasonValues() []BuildReason {

return []BuildReason{

BuildReasonInitiator,

BuildReasonAutostart,

BuildReasonAutostop,

BuildReasonDormancy,

BuildReasonFailedstop,

BuildReasonAutodelete,

}

}

type CryptoKeyFeature string

const (

CryptoKeyFeatureWorkspaceAppsToken CryptoKeyFeature = "workspace_apps_token"

CryptoKeyFeatureWorkspaceAppsAPIKey CryptoKeyFeature = "workspace_apps_api_key"

CryptoKeyFeatureOIDCConvert CryptoKeyFeature = "oidc_convert"

CryptoKeyFeatureTailnetResume CryptoKeyFeature = "tailnet_resume"

)

func (e *CryptoKeyFeature) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = CryptoKeyFeature(s)

case string:

*e = CryptoKeyFeature(s)

default:

return fmt.Errorf("unsupported scan type for CryptoKeyFeature: %T", src)

}

return nil

}

type NullCryptoKeyFeature struct {

CryptoKeyFeature CryptoKeyFeature `json:"crypto_key_feature"`

Valid bool `json:"valid"` // Valid is true if CryptoKeyFeature is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullCryptoKeyFeature) Scan(value interface{}) error {

if value == nil {

ns.CryptoKeyFeature, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.CryptoKeyFeature.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullCryptoKeyFeature) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.CryptoKeyFeature), nil

}

func (e CryptoKeyFeature) Valid() bool {

switch e {

case CryptoKeyFeatureWorkspaceAppsToken,

CryptoKeyFeatureWorkspaceAppsAPIKey,

CryptoKeyFeatureOIDCConvert,

CryptoKeyFeatureTailnetResume:

return true

}

return false

}

func AllCryptoKeyFeatureValues() []CryptoKeyFeature {

return []CryptoKeyFeature{

CryptoKeyFeatureWorkspaceAppsToken,

CryptoKeyFeatureWorkspaceAppsAPIKey,

CryptoKeyFeatureOIDCConvert,

CryptoKeyFeatureTailnetResume,

}

}

type DisplayApp string

const (

DisplayAppVscode DisplayApp = "vscode"

DisplayAppVscodeInsiders DisplayApp = "vscode_insiders"

DisplayAppWebTerminal DisplayApp = "web_terminal"

DisplayAppSSHHelper DisplayApp = "ssh_helper"

DisplayAppPortForwardingHelper DisplayApp = "port_forwarding_helper"

)

func (e *DisplayApp) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = DisplayApp(s)

case string:

*e = DisplayApp(s)

default:

return fmt.Errorf("unsupported scan type for DisplayApp: %T", src)

}

return nil

}

type NullDisplayApp struct {

DisplayApp DisplayApp `json:"display_app"`

Valid bool `json:"valid"` // Valid is true if DisplayApp is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullDisplayApp) Scan(value interface{}) error {

if value == nil {

ns.DisplayApp, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.DisplayApp.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullDisplayApp) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.DisplayApp), nil

}

func (e DisplayApp) Valid() bool {

switch e {

case DisplayAppVscode,

DisplayAppVscodeInsiders,

DisplayAppWebTerminal,

DisplayAppSSHHelper,

DisplayAppPortForwardingHelper:

return true

}

return false

}

func AllDisplayAppValues() []DisplayApp {

return []DisplayApp{

DisplayAppVscode,

DisplayAppVscodeInsiders,

DisplayAppWebTerminal,

DisplayAppSSHHelper,

DisplayAppPortForwardingHelper,

}

}

type GroupSource string

const (

GroupSourceUser GroupSource = "user"

GroupSourceOidc GroupSource = "oidc"

)

func (e *GroupSource) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = GroupSource(s)

case string:

*e = GroupSource(s)

default:

return fmt.Errorf("unsupported scan type for GroupSource: %T", src)

}

return nil

}

type NullGroupSource struct {

GroupSource GroupSource `json:"group_source"`

Valid bool `json:"valid"` // Valid is true if GroupSource is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullGroupSource) Scan(value interface{}) error {

if value == nil {

ns.GroupSource, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.GroupSource.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullGroupSource) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.GroupSource), nil

}

func (e GroupSource) Valid() bool {

switch e {

case GroupSourceUser,

GroupSourceOidc:

return true

}

return false

}

func AllGroupSourceValues() []GroupSource {

return []GroupSource{

GroupSourceUser,

GroupSourceOidc,

}

}

type LogLevel string

const (

LogLevelTrace LogLevel = "trace"

LogLevelDebug LogLevel = "debug"

LogLevelInfo LogLevel = "info"

LogLevelWarn LogLevel = "warn"

LogLevelError LogLevel = "error"

)

func (e *LogLevel) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = LogLevel(s)

case string:

*e = LogLevel(s)

default:

return fmt.Errorf("unsupported scan type for LogLevel: %T", src)

}

return nil

}

type NullLogLevel struct {

LogLevel LogLevel `json:"log_level"`

Valid bool `json:"valid"` // Valid is true if LogLevel is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullLogLevel) Scan(value interface{}) error {

if value == nil {

ns.LogLevel, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.LogLevel.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullLogLevel) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.LogLevel), nil

}

func (e LogLevel) Valid() bool {

switch e {

case LogLevelTrace,

LogLevelDebug,

LogLevelInfo,

LogLevelWarn,

LogLevelError:

return true

}

return false

}

func AllLogLevelValues() []LogLevel {

return []LogLevel{

LogLevelTrace,

LogLevelDebug,

LogLevelInfo,

LogLevelWarn,

LogLevelError,

}

}

type LogSource string

const (

LogSourceProvisionerDaemon LogSource = "provisioner_daemon"

LogSourceProvisioner LogSource = "provisioner"

)

func (e *LogSource) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = LogSource(s)

case string:

*e = LogSource(s)

default:

return fmt.Errorf("unsupported scan type for LogSource: %T", src)

}

return nil

}

type NullLogSource struct {

LogSource LogSource `json:"log_source"`

Valid bool `json:"valid"` // Valid is true if LogSource is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullLogSource) Scan(value interface{}) error {

if value == nil {

ns.LogSource, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.LogSource.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullLogSource) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.LogSource), nil

}

func (e LogSource) Valid() bool {

switch e {

case LogSourceProvisionerDaemon,

LogSourceProvisioner:

return true

}

return false

}

func AllLogSourceValues() []LogSource {

return []LogSource{

LogSourceProvisionerDaemon,

LogSourceProvisioner,

}

}

// Specifies the method of authentication. "none" is a special case in which no authentication method is allowed.

type LoginType string

const (

LoginTypePassword LoginType = "password"

LoginTypeGithub LoginType = "github"

LoginTypeOIDC LoginType = "oidc"

LoginTypeToken LoginType = "token"

LoginTypeNone LoginType = "none"

LoginTypeOAuth2ProviderApp LoginType = "oauth2_provider_app"

)

func (e *LoginType) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = LoginType(s)

case string:

*e = LoginType(s)

default:

return fmt.Errorf("unsupported scan type for LoginType: %T", src)

}

return nil

}

type NullLoginType struct {

LoginType LoginType `json:"login_type"`

Valid bool `json:"valid"` // Valid is true if LoginType is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullLoginType) Scan(value interface{}) error {

if value == nil {

ns.LoginType, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.LoginType.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullLoginType) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.LoginType), nil

}

func (e LoginType) Valid() bool {

switch e {

case LoginTypePassword,

LoginTypeGithub,

LoginTypeOIDC,

LoginTypeToken,

LoginTypeNone,

LoginTypeOAuth2ProviderApp:

return true

}

return false

}

func AllLoginTypeValues() []LoginType {

return []LoginType{

LoginTypePassword,

LoginTypeGithub,

LoginTypeOIDC,

LoginTypeToken,

LoginTypeNone,

LoginTypeOAuth2ProviderApp,

}

}

type NotificationMessageStatus string

const (

NotificationMessageStatusPending NotificationMessageStatus = "pending"

NotificationMessageStatusLeased NotificationMessageStatus = "leased"

NotificationMessageStatusSent NotificationMessageStatus = "sent"

NotificationMessageStatusPermanentFailure NotificationMessageStatus = "permanent_failure"

NotificationMessageStatusTemporaryFailure NotificationMessageStatus = "temporary_failure"

NotificationMessageStatusUnknown NotificationMessageStatus = "unknown"

NotificationMessageStatusInhibited NotificationMessageStatus = "inhibited"

)

func (e *NotificationMessageStatus) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = NotificationMessageStatus(s)

case string:

*e = NotificationMessageStatus(s)

default:

return fmt.Errorf("unsupported scan type for NotificationMessageStatus: %T", src)

}

return nil

}

type NullNotificationMessageStatus struct {

NotificationMessageStatus NotificationMessageStatus `json:"notification_message_status"`

Valid bool `json:"valid"` // Valid is true if NotificationMessageStatus is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullNotificationMessageStatus) Scan(value interface{}) error {

if value == nil {

ns.NotificationMessageStatus, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.NotificationMessageStatus.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullNotificationMessageStatus) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.NotificationMessageStatus), nil

}

func (e NotificationMessageStatus) Valid() bool {

switch e {

case NotificationMessageStatusPending,

NotificationMessageStatusLeased,

NotificationMessageStatusSent,

NotificationMessageStatusPermanentFailure,

NotificationMessageStatusTemporaryFailure,

NotificationMessageStatusUnknown,

NotificationMessageStatusInhibited:

return true

}

return false

}

func AllNotificationMessageStatusValues() []NotificationMessageStatus {

return []NotificationMessageStatus{

NotificationMessageStatusPending,

NotificationMessageStatusLeased,

NotificationMessageStatusSent,

NotificationMessageStatusPermanentFailure,

NotificationMessageStatusTemporaryFailure,

NotificationMessageStatusUnknown,

NotificationMessageStatusInhibited,

}

}

type NotificationMethod string

const (

NotificationMethodSmtp NotificationMethod = "smtp"

NotificationMethodWebhook NotificationMethod = "webhook"

)

func (e *NotificationMethod) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = NotificationMethod(s)

case string:

*e = NotificationMethod(s)

default:

return fmt.Errorf("unsupported scan type for NotificationMethod: %T", src)

}

return nil

}

type NullNotificationMethod struct {

NotificationMethod NotificationMethod `json:"notification_method"`

Valid bool `json:"valid"` // Valid is true if NotificationMethod is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullNotificationMethod) Scan(value interface{}) error {

if value == nil {

ns.NotificationMethod, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.NotificationMethod.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullNotificationMethod) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.NotificationMethod), nil

}

func (e NotificationMethod) Valid() bool {

switch e {

case NotificationMethodSmtp,

NotificationMethodWebhook:

return true

}

return false

}

func AllNotificationMethodValues() []NotificationMethod {

return []NotificationMethod{

NotificationMethodSmtp,

NotificationMethodWebhook,

}

}

type NotificationTemplateKind string

const (

NotificationTemplateKindSystem NotificationTemplateKind = "system"

)

func (e *NotificationTemplateKind) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = NotificationTemplateKind(s)

case string:

*e = NotificationTemplateKind(s)

default:

return fmt.Errorf("unsupported scan type for NotificationTemplateKind: %T", src)

}

return nil

}

type NullNotificationTemplateKind struct {

NotificationTemplateKind NotificationTemplateKind `json:"notification_template_kind"`

Valid bool `json:"valid"` // Valid is true if NotificationTemplateKind is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullNotificationTemplateKind) Scan(value interface{}) error {

if value == nil {

ns.NotificationTemplateKind, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.NotificationTemplateKind.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullNotificationTemplateKind) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.NotificationTemplateKind), nil

}

func (e NotificationTemplateKind) Valid() bool {

switch e {

case NotificationTemplateKindSystem:

return true

}

return false

}

func AllNotificationTemplateKindValues() []NotificationTemplateKind {

return []NotificationTemplateKind{

NotificationTemplateKindSystem,

}

}

type ParameterDestinationScheme string

const (

ParameterDestinationSchemeNone ParameterDestinationScheme = "none"

ParameterDestinationSchemeEnvironmentVariable ParameterDestinationScheme = "environment_variable"

ParameterDestinationSchemeProvisionerVariable ParameterDestinationScheme = "provisioner_variable"

)

func (e *ParameterDestinationScheme) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = ParameterDestinationScheme(s)

case string:

*e = ParameterDestinationScheme(s)

default:

return fmt.Errorf("unsupported scan type for ParameterDestinationScheme: %T", src)

}

return nil

}

type NullParameterDestinationScheme struct {

ParameterDestinationScheme ParameterDestinationScheme `json:"parameter_destination_scheme"`

Valid bool `json:"valid"` // Valid is true if ParameterDestinationScheme is not NULL

}

// Scan implements the Scanner interface.

func (ns *NullParameterDestinationScheme) Scan(value interface{}) error {

if value == nil {

ns.ParameterDestinationScheme, ns.Valid = "", false

return nil

}

ns.Valid = true

return ns.ParameterDestinationScheme.Scan(value)

}

// Value implements the driver Valuer interface.

func (ns NullParameterDestinationScheme) Value() (driver.Value, error) {

if !ns.Valid {

return nil, nil

}

return string(ns.ParameterDestinationScheme), nil

}

func (e ParameterDestinationScheme) Valid() bool {

switch e {

case ParameterDestinationSchemeNone,

ParameterDestinationSchemeEnvironmentVariable,

ParameterDestinationSchemeProvisionerVariable:

return true

}

return false

}

func AllParameterDestinationSchemeValues() []ParameterDestinationScheme {

return []ParameterDestinationScheme{

ParameterDestinationSchemeNone,

ParameterDestinationSchemeEnvironmentVariable,

ParameterDestinationSchemeProvisionerVariable,

}

}

type ParameterScope string

const (

ParameterScopeTemplate ParameterScope = "template"

ParameterScopeImportJob ParameterScope = "import_job"

ParameterScopeWorkspace ParameterScope = "workspace"

)

func (e *ParameterScope) Scan(src interface{}) error {

switch s := src.(type) {

case []byte:

*e = ParameterScope(s)

case string:

*e = ParameterScope(s)

default:

return fmt.Errorf("unsupported scan type for ParameterScope: %T", src)

}

return nil

}

type NullParameterScope struct {

ParameterScope ParameterScope `json:"parameter_scope"`

Valid bool `json:"valid"` // Valid is true if ParameterScope is not NULL

}