types

var (
	// DiskConnections ディスク接続方法
	DiskConnections = struct {
		// VirtIO virtio
		VirtIO EDiskConnection
		// IDE ide
		IDE EDiskConnection
	}{
		VirtIO: EDiskConnection("virtio"),
		IDE:    EDiskConnection("ide"),
	}

	// DiskConnectionMap 文字列とDiskConnectionのマップ
	DiskConnectionMap = map[string]EDiskConnection{
		DiskConnections.VirtIO.String(): DiskConnections.VirtIO,
		DiskConnections.IDE.String():    DiskConnections.IDE,
	}

	// DiskConnectionStrings DiskConnectionに指定できる有効な文字列
	DiskConnectionStrings = []string{
		DiskConnections.VirtIO.String(),
		DiskConnections.IDE.String(),
	}
)

var (
	// DiskEncryptionAlgorithms ディスク接続方法
	DiskEncryptionAlgorithms = struct {
		// None unencrypted
		None EDiskEncryptionAlgorithm
		// AES256XTS aes256_xts
		AES256XTS EDiskEncryptionAlgorithm
	}{
		None:      EDiskEncryptionAlgorithm("none"),
		AES256XTS: EDiskEncryptionAlgorithm("aes256_xts"),
	}

	// DiskEncryptionAlgorithmMap 文字列とDiskEncryptionAlgorithmのマップ
	DiskEncryptionAlgorithmMap = map[string]EDiskEncryptionAlgorithm{
		DiskEncryptionAlgorithms.None.String():      DiskEncryptionAlgorithms.None,
		DiskEncryptionAlgorithms.AES256XTS.String(): DiskEncryptionAlgorithms.AES256XTS,
	}

	// DiskEncryptionAlgorithmStrings DiskEncryptionAlgorithmに指定できる有効な文字列
	DiskEncryptionAlgorithmStrings = []string{
		DiskEncryptionAlgorithms.None.String(),
		DiskEncryptionAlgorithms.AES256XTS.String(),
	}
)

var (
	// InterfaceDrivers インターフェースドライバ
	InterfaceDrivers = struct {
		VirtIO EInterfaceDriver // virtio
		E1000  EInterfaceDriver // e1000
	}{
		VirtIO: EInterfaceDriver("virtio"),
		E1000:  EInterfaceDriver("e1000"),
	}

	// InterfaceDriverMap インターフェースドライバと文字列表現のマップ
	InterfaceDriverMap = map[string]EInterfaceDriver{
		InterfaceDrivers.VirtIO.String(): InterfaceDrivers.VirtIO,
		InterfaceDrivers.E1000.String():  InterfaceDrivers.E1000,
	}

	// InterfaceDriverValues インターフェースドライバが取りうる有効値
	InterfaceDriverValues = []string{
		InterfaceDrivers.VirtIO.String(),
		InterfaceDrivers.E1000.String(),
	}
)

var (
	// PlanGenerationValues 有効なサーバプラン世代の値
	PlanGenerationValues = []int{
		int(PlanGenerations.Default),
		int(PlanGenerations.G100),
		int(PlanGenerations.G200),
	}

	// PlanGenerations サーバプラン世代
	PlanGenerations = struct {
		// Default デフォルト(自動選択)
		Default EPlanGeneration
		// G100 第1世代
		G100 EPlanGeneration
		// G200 第2世代
		G200 EPlanGeneration
	}{
		Default: EPlanGeneration(0),
		G100:    EPlanGeneration(100),
		G200:    EPlanGeneration(200),
	}
)

var (
	// StringTrue true値
	StringTrue = StringFlag(true)
	// StringFalse false値
	StringFalse = StringFlag(false)
)

var (
	// UpstreamNetworkTypes 上流ネットワーク種別
	UpstreamNetworkTypes = struct {
		Unknown EUpstreamNetworkType
		// Shared 共有セグメント
		Shared EUpstreamNetworkType
		// Switch スイッチ
		Switch EUpstreamNetworkType
		// Router ルータ
		Router EUpstreamNetworkType
		// None 接続なし
		None EUpstreamNetworkType
	}{
		Unknown: EUpstreamNetworkType("unknown"),
		Shared:  EUpstreamNetworkType("shared"),
		Switch:  EUpstreamNetworkType("switch"),
		Router:  EUpstreamNetworkType("router"),
		None:    EUpstreamNetworkType("none"),
	}

	// UpstreamNetworkTypeMap 文字列とEUpstreamNetworkTypeのマッピング
	UpstreamNetworkTypeMap = map[string]EUpstreamNetworkType{
		"unknown": UpstreamNetworkTypes.Unknown,
		"shared":  UpstreamNetworkTypes.Shared,
		"switch":  UpstreamNetworkTypes.Switch,
		"router":  UpstreamNetworkTypes.Router,
		"none":    UpstreamNetworkTypes.None,
	}
)

var (
	VPCRouterSiteToSiteVPNEncryptionAlgos = []string{
		VPCRouterSiteToSiteVPNEncryptionAlgoAES128,
		VPCRouterSiteToSiteVPNEncryptionAlgoAES256,
	}
	VPCRouterSiteToSiteVPNHashAlgos = []string{
		VPCRouterSiteToSiteVPNHashAlgoSHA1,
		VPCRouterSiteToSiteVPNHashAlgoSHA256,
	}
	VPCRouterSiteToSiteVPNDHGroups = []string{
		VPCRouterSiteToSiteVPNDHGroupModp1024,
		VPCRouterSiteToSiteVPNDHGroupModp2048,
		VPCRouterSiteToSiteVPNDHGroupModp3072,
		VPCRouterSiteToSiteVPNDHGroupModp4096,
	}
)

var ActionStrings = []string{
	Actions.Allow.String(),
	Actions.Deny.String(),
}

var Actions = &struct {
	Allow Action
	Deny  Action
}{
	Allow: Action("allow"),
	Deny:  Action("deny"),
}

var ArchiveSizes = []int{20, 40, 60, 80, 100, 250, 500, 750, 1024}

var AuthClasses = struct {
	// Unknown 不明
	Unknown EAuthClass
	// Account アカウント認証
	Account EAuthClass
}{
	Unknown: EAuthClass(""),
	Account: EAuthClass("account"),
}

var AuthMethods = struct {
	// Unknown 不明
	Unknown EAuthMethod
	// APIKey APIキーによる認証
	APIKey EAuthMethod
}{
	Unknown: EAuthMethod(""),
	APIKey:  EAuthMethod("apikey"),
}

var AutoScaleActionStrings = []string{"cpu", "router", "schedule"}

var AutoScaleActions = struct {
	// Up .
	Up EAutoScaleAction
	// Down .
	Down EAutoScaleAction
}{
	Up:   EAutoScaleAction("up"),
	Down: EAutoScaleAction("down"),
}

var AutoScaleTriggerTypeStrings = []string{"cpu", "router", "schedule"}

var AutoScaleTriggerTypes = struct {
	// Default CPUトリガーがデフォルト
	Default EAutoScaleTriggerType
	// Standard 通常
	CPU EAutoScaleTriggerType
	// DedicatedCPU コア専有
	Router EAutoScaleTriggerType
	// DedicatedCPU コア専有
	Schedule EAutoScaleTriggerType
}{
	Default:  EAutoScaleTriggerType(""),
	CPU:      EAutoScaleTriggerType("cpu"),
	Router:   EAutoScaleTriggerType("router"),
	Schedule: EAutoScaleTriggerType("schedule"),
}

var Availabilities = struct {
	// Unknown 不明
	Unknown EAvailability
	// Available 有効
	Available EAvailability // 有効
	// Uploading アップロード中
	Uploading EAvailability // アップロード中
	// Failed 失敗
	Failed EAvailability // 失敗
	// Migrating マイグレーション中
	Migrating EAvailability
	// Transferring 転送中(他ゾーンからのアーカイブコピー作成など)
	Transferring EAvailability
	// Discontinued 切断(ソースアーカイブ/ソースディスクなどで利用される)
	Discontinued EAvailability
}{
	Unknown:      EAvailability(""),
	Available:    EAvailability("available"),
	Uploading:    EAvailability("uploading"),
	Failed:       EAvailability("failed"),
	Migrating:    EAvailability("migrating"),
	Transferring: EAvailability("transfering"),
	Discontinued: EAvailability("discontinued"),
}

var BackupSpanTypes = struct {
	// Weekdays 曜日
	Weekdays EBackupSpanType
}{
	Weekdays: EBackupSpanType("weekdays"),
}

var CertificateAuthorityIssuanceMethodStrings = []string{
	CertificateAuthorityIssuanceMethods.URL.String(),
	CertificateAuthorityIssuanceMethods.EMail.String(),
	CertificateAuthorityIssuanceMethods.PublicKey.String(),
	CertificateAuthorityIssuanceMethods.CSR.String(),
}

var CertificateAuthorityIssuanceMethods = struct {
	URL       ECertificateAuthorityIssuanceMethod
	EMail     ECertificateAuthorityIssuanceMethod
	PublicKey ECertificateAuthorityIssuanceMethod
	CSR       ECertificateAuthorityIssuanceMethod
}{
	URL:       ECertificateAuthorityIssuanceMethod("url"),
	EMail:     ECertificateAuthorityIssuanceMethod("email"),
	PublicKey: ECertificateAuthorityIssuanceMethod("public_key"),
	CSR:       ECertificateAuthorityIssuanceMethod("csr"),
}

var CommitmentStrings = []string{"standard", "dedicatedcpu"}

var Commitments = struct {
	// Unknown 不明
	Unknown ECommitment
	// Standard 通常
	Standard ECommitment
	// DedicatedCPU コア専有
	DedicatedCPU ECommitment
}{
	Unknown:      ECommitment(""),
	Standard:     ECommitment("standard"),
	DedicatedCPU: ECommitment("dedicatedcpu"),
}

var ContainerRegistryAccessLevelMap = map[string]EContainerRegistryAccessLevel{
	ContainerRegistryAccessLevels.ReadWrite.String(): ContainerRegistryAccessLevels.ReadWrite,
	ContainerRegistryAccessLevels.ReadOnly.String():  ContainerRegistryAccessLevels.ReadOnly,
	ContainerRegistryAccessLevels.None.String():      ContainerRegistryAccessLevels.None,
}

var ContainerRegistryAccessLevelStrings = []string{
	ContainerRegistryAccessLevels.ReadWrite.String(),
	ContainerRegistryAccessLevels.ReadOnly.String(),
	ContainerRegistryAccessLevels.None.String(),
}

var ContainerRegistryAccessLevels = struct {
	ReadWrite EContainerRegistryAccessLevel
	ReadOnly  EContainerRegistryAccessLevel
	None      EContainerRegistryAccessLevel
}{
	ReadWrite: "readwrite",
	ReadOnly:  "readonly",
	None:      "none",
}

var ContainerRegistryPermissionMap = map[string]EContainerRegistryPermission{
	ContainerRegistryPermissions.All.String():       ContainerRegistryPermissions.All,
	ContainerRegistryPermissions.ReadWrite.String(): ContainerRegistryPermissions.ReadWrite,
	ContainerRegistryPermissions.ReadOnly.String():  ContainerRegistryPermissions.ReadOnly,
}

var ContainerRegistryPermissionStrings = []string{
	ContainerRegistryPermissions.All.String(),
	ContainerRegistryPermissions.ReadWrite.String(),
	ContainerRegistryPermissions.ReadOnly.String(),
}

var ContainerRegistryPermissions = struct {
	All       EContainerRegistryPermission
	ReadWrite EContainerRegistryPermission
	ReadOnly  EContainerRegistryPermission
}{
	All:       "all",
	ReadWrite: "readwrite",
	ReadOnly:  "readonly",
}

var DNSRecordTypeStrings = []string{
	DNSRecordTypes.A.String(),
	DNSRecordTypes.AAAA.String(),
	DNSRecordTypes.ALIAS.String(),
	DNSRecordTypes.CNAME.String(),
	DNSRecordTypes.NS.String(),
	DNSRecordTypes.MX.String(),
	DNSRecordTypes.TXT.String(),
	DNSRecordTypes.SRV.String(),
	DNSRecordTypes.CAA.String(),
	DNSRecordTypes.HTTPS.String(),
	DNSRecordTypes.SVCB.String(),
	DNSRecordTypes.PTR.String(),
}

var DNSRecordTypes = struct {
	// A Aレコード
	A EDNSRecordType
	// AAAA AAAAレコード
	AAAA EDNSRecordType
	// ALIAS ALIASレコード
	ALIAS EDNSRecordType
	// CNAME CNAMEレコード
	CNAME EDNSRecordType
	// NS NSレコード
	NS EDNSRecordType
	// MX MXレコード
	MX EDNSRecordType
	// TXT TXTレコード
	TXT EDNSRecordType
	// SRV SRVレコード
	SRV EDNSRecordType
	// CAA CAAレコード
	CAA EDNSRecordType
	// HTTPS HTTPSレコード
	HTTPS EDNSRecordType
	// SVCB SVCBレコード
	SVCB EDNSRecordType
	// PTR PTRレコード
	PTR EDNSRecordType
}{
	A:     EDNSRecordType("A"),
	AAAA:  EDNSRecordType("AAAA"),
	ALIAS: EDNSRecordType("ALIAS"),
	CNAME: EDNSRecordType("CNAME"),
	NS:    EDNSRecordType("NS"),
	MX:    EDNSRecordType("MX"),
	TXT:   EDNSRecordType("TXT"),
	SRV:   EDNSRecordType("SRV"),
	CAA:   EDNSRecordType("CAA"),
	HTTPS: EDNSRecordType("HTTPS"),
	SVCB:  EDNSRecordType("SVCB"),
	PTR:   EDNSRecordType("PTR"),
}

var DatabasePlanIDMap = map[string]ID{
	"10g":  DatabasePlans.DB10GB,
	"30g":  DatabasePlans.DB30GB,
	"90g":  DatabasePlans.DB90GB,
	"240g": DatabasePlans.DB240GB,
	"500g": DatabasePlans.DB500GB,
	"1t":   DatabasePlans.DB1TB,
}

var DatabasePlanIDs = []ID{
	DatabasePlans.DB10GB,
	DatabasePlans.DB30GB,
	DatabasePlans.DB90GB,
	DatabasePlans.DB240GB,
	DatabasePlans.DB500GB,
	DatabasePlans.DB1TB,
}

var DatabasePlanNameMap = map[ID]string{
	DatabasePlans.DB10GB:  "10g",
	DatabasePlans.DB30GB:  "30g",
	DatabasePlans.DB90GB:  "90g",
	DatabasePlans.DB240GB: "240g",
	DatabasePlans.DB500GB: "500g",
	DatabasePlans.DB1TB:   "1t",
}

var DatabasePlanStrings = []string{"10g", "30g", "90g", "240g", "500g", "1t"}

var DatabasePlans = struct {
	// DB10GB 10GB
	DB10GB ID
	// DB30GB 30GB
	DB30GB ID
	// DB90GB 90GB
	DB90GB ID
	// DB240GB 240GB
	DB240GB ID
	// DB500GB 500GB
	DB500GB ID
	// DB1TB 1TB
	DB1TB ID
}{
	DB10GB:  ID(10),
	DB30GB:  ID(30),
	DB90GB:  ID(90),
	DB240GB: ID(240),
	DB500GB: ID(500),
	DB1TB:   ID(1000),
}

var DatabaseReplicationModels = struct {
	// MasterSlave マスター側
	MasterSlave EDatabaseReplicationModel
	// AsyncReplica スレーブ側
	AsyncReplica EDatabaseReplicationModel
}{
	MasterSlave:  EDatabaseReplicationModel("Master-Slave"),
	AsyncReplica: EDatabaseReplicationModel("Async-Replica"),
}

var DatetimeLayout = "2006-01-02T15:04:05-07:00"

var DaysOfTheWeek = struct {
	Sunday    EDayOfTheWeek
	Monday    EDayOfTheWeek
	Tuesday   EDayOfTheWeek
	Wednesday EDayOfTheWeek
	Thursday  EDayOfTheWeek
	Friday    EDayOfTheWeek
	Saturday  EDayOfTheWeek
}{
	Sunday:    EDayOfTheWeek("sun"),
	Monday:    EDayOfTheWeek("mon"),
	Tuesday:   EDayOfTheWeek("tue"),
	Wednesday: EDayOfTheWeek("wed"),
	Thursday:  EDayOfTheWeek("thu"),
	Friday:    EDayOfTheWeek("fri"),
	Saturday:  EDayOfTheWeek("sat"),
}

var DaysOfTheWeekStrings = []string{
	DaysOfTheWeek.Sunday.String(),
	DaysOfTheWeek.Monday.String(),
	DaysOfTheWeek.Tuesday.String(),
	DaysOfTheWeek.Wednesday.String(),
	DaysOfTheWeek.Thursday.String(),
	DaysOfTheWeek.Friday.String(),
	DaysOfTheWeek.Saturday.String(),
}

var DiskPlanIDMap = map[string]ID{
	"ssd": DiskPlans.SSD,
	"hdd": DiskPlans.HDD,
}

var DiskPlanNameMap = map[ID]string{
	DiskPlans.SSD: "ssd",
	DiskPlans.HDD: "hdd",
}

var DiskPlanStrings = []string{"ssd", "hdd"}

var DiskPlans = struct {
	// SSD ssdプラン
	SSD ID
	// HDD hddプラン
	HDD ID
}{
	SSD: ID(4),
	HDD: ID(2),
}

var EnhancedDBRegionStrings = []string{
	strings.ToLower(EnhancedDBRegionsIs1.String()),
	strings.ToLower(EnhancedDBRegionsTk1.String()),
}

var EnhancedDBTypeStrings = []string{
	strings.ToLower(EnhancedDBTypesTiDB.String()),
	strings.ToLower(EnhancedDBTypesMariaDB.String()),
}

var GSLBHealthCheckProtocolStrings = []string{
	GSLBHealthCheckProtocols.HTTP.String(),
	GSLBHealthCheckProtocols.HTTPS.String(),
	GSLBHealthCheckProtocols.TCP.String(),
	GSLBHealthCheckProtocols.Ping.String(),
}

var GSLBHealthCheckProtocols = struct {
	// HTTP http
	HTTP EGSLBHealthCheckProtocol
	// HTTPS https
	HTTPS EGSLBHealthCheckProtocol
	// TCP tcp
	TCP EGSLBHealthCheckProtocol
	// Ping ping
	Ping EGSLBHealthCheckProtocol
}{
	HTTP:  EGSLBHealthCheckProtocol("http"),
	HTTPS: EGSLBHealthCheckProtocol("https"),
	TCP:   EGSLBHealthCheckProtocol("tcp"),
	Ping:  EGSLBHealthCheckProtocol("ping"),
}

var InterfaceDriverStrings = []string{"virtio", "e1000"}

var InternetBandWidths = []int{
	100, 250, 500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000,
	5500, 6000, 6500, 7000, 7500, 8000, 8500, 9000, 9500, 10000,
}

var InternetNetworkMaskLengths = []int{26, 27, 28}

var LoadBalancerHealthCheckProtocolStrings = []string{
	LoadBalancerHealthCheckProtocols.HTTP.String(),
	LoadBalancerHealthCheckProtocols.HTTPS.String(),
	LoadBalancerHealthCheckProtocols.TCP.String(),
	LoadBalancerHealthCheckProtocols.Ping.String(),
}

var LoadBalancerHealthCheckProtocols = struct {
	// HTTP http
	HTTP ELoadBalancerHealthCheckProtocol
	// HTTPS https
	HTTPS ELoadBalancerHealthCheckProtocol
	// TCP tcp
	TCP ELoadBalancerHealthCheckProtocol
	// Ping ping
	Ping ELoadBalancerHealthCheckProtocol
}{
	HTTP:  ELoadBalancerHealthCheckProtocol("http"),
	HTTPS: ELoadBalancerHealthCheckProtocol("https"),
	TCP:   ELoadBalancerHealthCheckProtocol("tcp"),
	Ping:  ELoadBalancerHealthCheckProtocol("ping"),
}

var LoadBalancerPlanIDNameMap = map[string]ID{
	"standard": LoadBalancerPlans.Standard,
	"highspec": LoadBalancerPlans.HighSpec,
}

var LoadBalancerPlanNameMap = map[ID]string{
	LoadBalancerPlans.Standard: "standard",
	LoadBalancerPlans.HighSpec: "highspec",
}

var LoadBalancerPlans = struct {
	// Standard スタンダード
	Standard ID
	// HighSpec プレミアム
	HighSpec ID
}{
	Standard: ID(1),
	HighSpec: ID(2),
}

var NFSHDDSizes = struct {
	Size100GB ENFSSize
	Size500GB ENFSSize
	Size1TB   ENFSSize
	Size2TB   ENFSSize
	Size4TB   ENFSSize
	Size8TB   ENFSSize
	Size12TB  ENFSSize
}{
	Size100GB: ENFSSize(100),
	Size500GB: ENFSSize(500),
	Size1TB:   ENFSSize(1024 * 1),
	Size2TB:   ENFSSize(1024 * 2),
	Size4TB:   ENFSSize(1024 * 4),
	Size8TB:   ENFSSize(1024 * 8),
	Size12TB:  ENFSSize(1024 * 12),
}

var NFSIntSizes = []int{
	int(NFSHDDSizes.Size100GB),
	int(NFSHDDSizes.Size500GB),
	int(NFSHDDSizes.Size1TB),
	int(NFSHDDSizes.Size2TB),
	int(NFSHDDSizes.Size4TB),
	int(NFSHDDSizes.Size8TB),
	int(NFSHDDSizes.Size12TB),
}

var NFSPlanIDMap = map[string]ID{
	"hdd": NFSPlans.HDD,
	"ssd": NFSPlans.SSD,
}

var NFSPlanNameMap = map[ID]string{
	NFSPlans.HDD: "hdd",
	NFSPlans.SSD: "ssd",
}

var NFSPlanStrings = []string{"hdd", "ssd"}

var NFSPlans = struct {
	// HDD hddプラン
	HDD ID
	// SSD ssdプラン
	SSD ID
}{
	HDD: ID(1),
	SSD: ID(2),
}

var NFSSSDSizes = struct {
	Size20GB  ENFSSize
	Size100GB ENFSSize
	Size500GB ENFSSize
	Size1TB   ENFSSize
	Size2TB   ENFSSize
	Size4TB   ENFSSize
}{
	Size20GB:  ENFSSize(20),
	Size100GB: ENFSSize(100),
	Size500GB: ENFSSize(500),
	Size1TB:   ENFSSize(1024 * 1),
	Size2TB:   ENFSSize(1024 * 2),
	Size4TB:   ENFSSize(1024 * 4),
}

var NoteClassString = strings.Join(NoteClassStrings, " ")

var NoteClassStrings = []string{
	"shell",
	"yaml_cloud_config",
}

var (
	OTPOperations = struct {
		Unknown  EOTPOperation
		Input    EOTPOperation
		Generate EOTPOperation
	}{
		Unknown:  EOTPOperation(""),
		Input:    EOTPOperation("input"),
		Generate: EOTPOperation("generate"),
	}
)

var OperationPenalties = struct {
	// Unknown 不明
	Unknown EOperationPenalty
	// None ペナルティなし
	None EOperationPenalty
}{
	Unknown: EOperationPenalty(""),
	None:    EOperationPenalty("none"),
}

var PacketFilterProtocolStrings = []string{
	Protocols.HTTP.String(),
	Protocols.HTTPS.String(),
	Protocols.TCP.String(),
	Protocols.UDP.String(),
	Protocols.ICMP.String(),
	Protocols.Fragment.String(),
	Protocols.IP.String(),
}

var Permissions = struct {
	// Unknown 不明
	Unknown EPermission
	// Create 作成・削除権限
	Create EPermission
	// Arrange 設定変更権限
	Arrange EPermission
	// Power 電源操作権限
	Power EPermission
	// View リソース閲覧権限
	View EPermission
}{
	Unknown: EPermission(""),
	Create:  EPermission("create"),
	Arrange: EPermission("arrange"),
	Power:   EPermission("power"),
	View:    EPermission("view"),
}

var PrivateHostClassString = strings.Join(PrivateHostClasses, " ")

var PrivateHostClasses = []string{PrivateHostClassDynamic, PrivateHostClassWindows}

var Protocols = &struct {
	HTTP     Protocol
	HTTPS    Protocol
	TCP      Protocol
	UDP      Protocol
	ICMP     Protocol
	Fragment Protocol
	IP       Protocol
}{
	HTTP:     "http",
	HTTPS:    "https",
	TCP:      "tcp",
	UDP:      "udp",
	ICMP:     "icmp",
	Fragment: "fragment",
	IP:       "ip",
}

var ProxyLBBackendHttpKeepAlive = struct {
	// SAFE クライアントからの接続に応じて実サーバとの持続的接続が使われ、クライアント間での接続の共有は行われにくい設定
	Safe EProxyLBBackendHttpKeepAlive
	// AGGRESSIVE 再使用可能な接続があればより積極的に使用する設定
	Aggressive EProxyLBBackendHttpKeepAlive
}{
	Safe:       EProxyLBBackendHttpKeepAlive("safe"),
	Aggressive: EProxyLBBackendHttpKeepAlive("aggressive"),
}

var ProxyLBBackendHttpKeepAliveStrings = []string{"safe", "aggressive"}

var ProxyLBFixedContentTypes = struct {
	Plain      EProxyLBFixedContentType
	HTML       EProxyLBFixedContentType
	JavaScript EProxyLBFixedContentType
	JSON       EProxyLBFixedContentType
}{
	Plain:      "text/plain",
	HTML:       "text/html",
	JavaScript: "application/javascript",
	JSON:       "application/json",
}

var ProxyLBFixedStatusCodes = struct {
	OK                 EProxyLBFixedStatusCode
	Forbidden          EProxyLBFixedStatusCode
	ServiceUnavailable EProxyLBFixedStatusCode
}{
	OK:                 EProxyLBFixedStatusCode(200),
	Forbidden:          EProxyLBFixedStatusCode(403),
	ServiceUnavailable: EProxyLBFixedStatusCode(503),
}

var ProxyLBPlanString = strings.Join([]string{
	ProxyLBPlans.CPS100.String(),
	ProxyLBPlans.CPS500.String(),
	ProxyLBPlans.CPS1000.String(),
	ProxyLBPlans.CPS5000.String(),
	ProxyLBPlans.CPS10000.String(),
	ProxyLBPlans.CPS50000.String(),
	ProxyLBPlans.CPS100000.String(),
	ProxyLBPlans.CPS400000.String(),
}, " ")

var ProxyLBPlanValues = []int{
	int(ProxyLBPlans.CPS100),
	int(ProxyLBPlans.CPS500),
	int(ProxyLBPlans.CPS1000),
	int(ProxyLBPlans.CPS5000),
	int(ProxyLBPlans.CPS10000),
	int(ProxyLBPlans.CPS50000),
	int(ProxyLBPlans.CPS100000),
	int(ProxyLBPlans.CPS400000),
}

var ProxyLBPlans = struct {
	CPS100    EProxyLBPlan
	CPS500    EProxyLBPlan
	CPS1000   EProxyLBPlan
	CPS5000   EProxyLBPlan
	CPS10000  EProxyLBPlan
	CPS50000  EProxyLBPlan
	CPS100000 EProxyLBPlan
	CPS400000 EProxyLBPlan
}{
	CPS100:    EProxyLBPlan(100),
	CPS500:    EProxyLBPlan(500),
	CPS1000:   EProxyLBPlan(1_000),
	CPS5000:   EProxyLBPlan(5_000),
	CPS10000:  EProxyLBPlan(10_000),
	CPS50000:  EProxyLBPlan(50_000),
	CPS100000: EProxyLBPlan(100_000),
	CPS400000: EProxyLBPlan(400_000),
}

var ProxyLBProtocolStrings = []string{"http", "tcp"}

var ProxyLBProtocols = struct {
	// HTTP http
	HTTP EProxyLBHealthCheckProtocol
	// TCP tcp
	TCP EProxyLBHealthCheckProtocol
}{
	HTTP: EProxyLBHealthCheckProtocol("http"),
	TCP:  EProxyLBHealthCheckProtocol("tcp"),
}

var ProxyLBProxyModeStrings = []string{"http", "https", "tcp"}

var ProxyLBProxyModes = struct {
	// HTTP .
	HTTP EProxyLBProxyMode
	// HTTPS .
	HTTPS EProxyLBProxyMode
	// TCP .
	TCP EProxyLBProxyMode
}{
	HTTP:  EProxyLBProxyMode("http"),
	HTTPS: EProxyLBProxyMode("https"),
	TCP:   EProxyLBProxyMode("tcp"),
}

var ProxyLBRedirectStatusCodes = struct {
	MovedPermanently EProxyLBRedirectStatusCode
	Found            EProxyLBRedirectStatusCode
}{
	MovedPermanently: EProxyLBRedirectStatusCode(301),
	Found:            EProxyLBRedirectStatusCode(302),
}

var ProxyLBRegionStrings = []string{"tk1", "is1", "anycast"}

var ProxyLBRegions = struct {
	// TK1 東京
	TK1 EProxyLBRegion
	// IS1 石狩
	IS1 EProxyLBRegion
	// Anycast エニーキャスト
	Anycast EProxyLBRegion
}{
	TK1:     EProxyLBRegion("tk1"),
	IS1:     EProxyLBRegion("is1"),
	Anycast: EProxyLBRegion("anycast"),
}

var ProxyLBRuleActions = struct {
	Forward  EProxyLBRuleAction
	Redirect EProxyLBRuleAction
	Fixed    EProxyLBRuleAction
}{
	Forward:  "forward",
	Redirect: "redirect",
	Fixed:    "fixed",
}

var ProxyLBSSLPolicies = []string{
	"TLS-1-2-2019-04",
	"TLS-1-2-2021-06",
	"TLS-1-3-2021-06",
}

var RDBMSTypeStrings = []string{
	strings.ToLower(RDBMSTypesMariaDB.String()),
	strings.ToLower(RDBMSTypesPostgreSQL.String()),
}

var SIMOperatorShortNameMap = map[string]ESIMOperatorName{
	"kddi":     SIMOperators.KDDI,
	"docomo":   SIMOperators.Docomo,
	"softbank": SIMOperators.SoftBank,
}

var SIMOperators = struct {
	KDDI     ESIMOperatorName
	Docomo   ESIMOperatorName
	SoftBank ESIMOperatorName
}{
	KDDI:     ESIMOperatorName("KDDI"),
	Docomo:   ESIMOperatorName("NTT DOCOMO"),
	SoftBank: ESIMOperatorName("SoftBank"),
}

var ScopeStrings = []string{
	Scopes.Shared.String(),
	Scopes.User.String(),
}

var Scopes = &struct {
	Shared EScope // 共有
	User   EScope // ユーザー
}{
	Shared: EScope("shared"),
	User:   EScope("user"),
}

var ServerInstanceStatuses = &struct {
	Unknown  EServerInstanceStatus
	Up       EServerInstanceStatus
	Cleaning EServerInstanceStatus
	Down     EServerInstanceStatus
}{
	Unknown:  EServerInstanceStatus(""),
	Up:       EServerInstanceStatus("up"),
	Cleaning: EServerInstanceStatus("cleaning"),
	Down:     EServerInstanceStatus("down"),
}

var SimpleMonitorFTPSStrings = []string{
	SimpleMonitorFTPSValues.Default.String(),
	SimpleMonitorFTPSValues.Implicit.String(),
	SimpleMonitorFTPSValues.Explicit.String(),
}

var SimpleMonitorFTPSValues = struct {
	Default  ESimpleMonitorFTPS
	Implicit ESimpleMonitorFTPS
	Explicit ESimpleMonitorFTPS
}{
	Default:  ESimpleMonitorFTPS(""),
	Implicit: ESimpleMonitorFTPS("implicit"),
	Explicit: ESimpleMonitorFTPS("explicit"),
}

var SimpleMonitorHealth = struct {
	// Up アップ
	Up ESimpleMonitorHealth
	// Down ダウン
	Down ESimpleMonitorHealth
}{
	Up:   ESimpleMonitorHealth("UP"),
	Down: ESimpleMonitorHealth("DOWN"),
}

var SimpleMonitorProtocolStrings = []string{
	SimpleMonitorProtocols.HTTP.String(),
	SimpleMonitorProtocols.HTTPS.String(),
	SimpleMonitorProtocols.Ping.String(),
	SimpleMonitorProtocols.TCP.String(),
	SimpleMonitorProtocols.DNS.String(),
	SimpleMonitorProtocols.SSH.String(),
	SimpleMonitorProtocols.SMTP.String(),
	SimpleMonitorProtocols.POP3.String(),
	SimpleMonitorProtocols.SNMP.String(),
	SimpleMonitorProtocols.SSLCertificate.String(),
	SimpleMonitorProtocols.FTP.String(),
}

var SimpleMonitorProtocols = struct {
	// HTTP http
	HTTP ESimpleMonitorProtocol
	// HTTPS https
	HTTPS ESimpleMonitorProtocol
	// Ping ping
	Ping ESimpleMonitorProtocol
	// TCP tcp
	TCP ESimpleMonitorProtocol
	// DNS dns
	DNS ESimpleMonitorProtocol
	// SSH ssh
	SSH ESimpleMonitorProtocol
	// SMTP smtp
	SMTP ESimpleMonitorProtocol
	// POP3 pop3
	POP3 ESimpleMonitorProtocol
	// SNMP snmp
	SNMP ESimpleMonitorProtocol
	// SSLCertificate sslcertificate
	SSLCertificate ESimpleMonitorProtocol
	// FTP ftp
	FTP ESimpleMonitorProtocol
}{
	HTTP:           ESimpleMonitorProtocol("http"),
	HTTPS:          ESimpleMonitorProtocol("https"),
	Ping:           ESimpleMonitorProtocol("ping"),
	TCP:            ESimpleMonitorProtocol("tcp"),
	DNS:            ESimpleMonitorProtocol("dns"),
	SSH:            ESimpleMonitorProtocol("ssh"),
	SMTP:           ESimpleMonitorProtocol("smtp"),
	POP3:           ESimpleMonitorProtocol("pop3"),
	SNMP:           ESimpleMonitorProtocol("snmp"),
	SSLCertificate: ESimpleMonitorProtocol("sslcertificate"),
	FTP:            ESimpleMonitorProtocol("ftp"),
}

var SpecialTags = struct {
	// GroupA サーバをグループ化し起動ホストを分離します(グループA)
	GroupA SpecialTag
	// GroupB サーバをグループ化し起動ホストを分離します(グループB)
	GroupB SpecialTag
	// GroupC サーバをグループ化し起動ホストを分離します(グループC)
	GroupC SpecialTag
	// GroupD サーバをグループ化し起動ホストを分離します(グループD)
	GroupD SpecialTag
	// AutoReboot サーバ停止時に自動起動します
	AutoReboot SpecialTag
	// KeyboardUS リモートスクリーン画面でUSキーボード入力します
	KeyboardUS SpecialTag
	// BootCDROM 優先ブートデバイスをCD-ROMに設定します
	BootCDROM SpecialTag
	// BootNetwork 優先ブートデバイスをPXE bootに設定します
	BootNetwork SpecialTag
	// CPUTopology CPUソケット数を1と認識させる
	CPUTopology SpecialTag
}{
	GroupA:      SpecialTag("@group=a"),
	GroupB:      SpecialTag("@group=b"),
	GroupC:      SpecialTag("@group=c"),
	GroupD:      SpecialTag("@group=d"),
	AutoReboot:  SpecialTag("@auto-reboot"),
	KeyboardUS:  SpecialTag("@keyboard-us"),
	BootCDROM:   SpecialTag("@boot-cdrom"),
	BootNetwork: SpecialTag("@boot-network"),
	CPUTopology: SpecialTag("@cpu-topology"),
}

var VPCRouterFirewallProtocolStrings = []string{"tcp", "udp", "icmp", "ip"}

var VPCRouterFirewallProtocols = struct {
	// TCP tcp
	TCP EVPCRouterFirewallProtocol
	// UDP udp
	UDP EVPCRouterFirewallProtocol
	// ICMP udp
	ICMP EVPCRouterFirewallProtocol
	// ICMP udp
	IP EVPCRouterFirewallProtocol
}{
	TCP:  EVPCRouterFirewallProtocol("tcp"),
	UDP:  EVPCRouterFirewallProtocol("udp"),
	ICMP: EVPCRouterFirewallProtocol("icmp"),
	IP:   EVPCRouterFirewallProtocol("ip"),
}

var VPCRouterPlanIDMap = map[string]ID{
	"standard":     VPCRouterPlans.Standard,
	"premium":      VPCRouterPlans.Premium,
	"highspec":     VPCRouterPlans.HighSpec,
	"highspec4000": VPCRouterPlans.HighSpec4000,
}

var VPCRouterPlanNameMap = map[ID]string{
	VPCRouterPlans.Standard:     "standard",
	VPCRouterPlans.Premium:      "premium",
	VPCRouterPlans.HighSpec:     "highspec",
	VPCRouterPlans.HighSpec4000: "highspec4000",
}

var VPCRouterPlanStrings = []string{"standard", "premium", "highspec", "highspec4000"}

var VPCRouterPlans = struct {
	// Standard スタンダードプラン シングル構成/最大スループット 80Mbps/一部機能は利用不可
	Standard ID
	// Premium プレミアムプラン 冗長構成/最大スループット400Mbps
	Premium ID
	// HighSpec ハイスペックプラン 冗長構成/最大スループット1,600Mbps
	HighSpec ID
	// HighSpec ハイスペックプラン 冗長構成/最大スループット4,000Mbps
	HighSpec4000 ID
}{
	Standard:     ID(1),
	Premium:      ID(2),
	HighSpec:     ID(3),
	HighSpec4000: ID(4),
}

var VPCRouterPortForwardingProtocols = struct {
	// TCP tcp
	TCP EVPCRouterPortForwardingProtocol
	// UDP udp
	UDP EVPCRouterPortForwardingProtocol
}{
	TCP: EVPCRouterPortForwardingProtocol("tcp"),
	UDP: EVPCRouterPortForwardingProtocol("udp"),
}

var WebAccelDomainTypes = struct {
	// Own 独自ドメイン
	Own EWebAccelDomainType
	// SubDomain サブドメイン
	SubDomain EWebAccelDomainType
}{
	Own:       EWebAccelDomainType("own_domain"),
	SubDomain: EWebAccelDomainType("subdomain"),
}

var WebAccelStatus = struct {
	// Enabled 有効
	Enabled EWebAccelStatus
	// Disabled 無効
	Disabled EWebAccelStatus
}{
	Enabled:  EWebAccelStatus("enabled"),
	Disabled: EWebAccelStatus("disabled"),
}

var ZoneIDs = map[string]ID{
	"tk1a": ZoneTk1aID,
	"tk1b": ZoneTk1bID,
	"is1a": ZoneIs1aID,
	"is1b": ZoneIs1bID,
	"tk1v": ZoneTk1vID,
}

var ZoneNames = []string{"tk1a", "tk1b", "is1a", "is1b", "tk1v"}