params_database_gen.go

// Copyright 2017-2020 The Usacloud Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by 'github.com/sacloud/usacloud/tools/gen-input-models'; DO NOT EDIT

package params

import (
	"github.com/sacloud/libsacloud/sacloud"
	"github.com/sacloud/usacloud/define"
	"github.com/sacloud/usacloud/output"
	"github.com/sacloud/usacloud/schema"
)

// ListDatabaseParam is input parameters for the sacloud API
type ListDatabaseParam struct {
	Name              []string     `json:"name"`
	Id                []sacloud.ID `json:"id"`
	Tags              []string     `json:"tags"`
	From              int          `json:"from"`
	Max               int          `json:"max"`
	Sort              []string     `json:"sort"`
	ParamTemplate     string       `json:"param-template"`
	ParamTemplateFile string       `json:"param-template-file"`
	GenerateSkeleton  bool         `json:"generate-skeleton"`
	OutputType        string       `json:"output-type"`
	Column            []string     `json:"column"`
	Quiet             bool         `json:"quiet"`
	Format            string       `json:"format"`
	FormatFile        string       `json:"format-file"`
	Query             string       `json:"query"`
	QueryFile         string       `json:"query-file"`
}

// NewListDatabaseParam return new ListDatabaseParam
func NewListDatabaseParam() *ListDatabaseParam {
	return &ListDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ListDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Name) {
		p.Name = []string{""}
	}
	if isEmpty(p.Id) {
		p.Id = []sacloud.ID{}
	}
	if isEmpty(p.Tags) {
		p.Tags = []string{""}
	}
	if isEmpty(p.From) {
		p.From = 0
	}
	if isEmpty(p.Max) {
		p.Max = 0
	}
	if isEmpty(p.Sort) {
		p.Sort = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}

}

// Validate checks current values in model
func (p *ListDatabaseParam) Validate() []error {
	errors := []error{}
	{
		errs := validateConflicts("--name", p.Name, map[string]interface{}{

			"--id": p.Id,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["list"].Params["id"].ValidateFunc
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--id", p.Id, map[string]interface{}{

			"--name": p.Name,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["list"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ListDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ListDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["list"]
}

func (p *ListDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ListDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ListDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ListDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ListDatabaseParam) SetName(v []string) {
	p.Name = v
}

func (p *ListDatabaseParam) GetName() []string {
	return p.Name
}
func (p *ListDatabaseParam) SetId(v []sacloud.ID) {
	p.Id = v
}

func (p *ListDatabaseParam) GetId() []sacloud.ID {
	return p.Id
}
func (p *ListDatabaseParam) SetTags(v []string) {
	p.Tags = v
}

func (p *ListDatabaseParam) GetTags() []string {
	return p.Tags
}
func (p *ListDatabaseParam) SetFrom(v int) {
	p.From = v
}

func (p *ListDatabaseParam) GetFrom() int {
	return p.From
}
func (p *ListDatabaseParam) SetMax(v int) {
	p.Max = v
}

func (p *ListDatabaseParam) GetMax() int {
	return p.Max
}
func (p *ListDatabaseParam) SetSort(v []string) {
	p.Sort = v
}

func (p *ListDatabaseParam) GetSort() []string {
	return p.Sort
}
func (p *ListDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ListDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ListDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ListDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ListDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ListDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ListDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *ListDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *ListDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *ListDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *ListDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *ListDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *ListDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *ListDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *ListDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *ListDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *ListDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *ListDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *ListDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *ListDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}

// CreateDatabaseParam is input parameters for the sacloud API
type CreateDatabaseParam struct {
	SwitchId            sacloud.ID `json:"switch-id"`
	Plan                int        `json:"plan"`
	Database            string     `json:"database"`
	Username            string     `json:"username"`
	Password            string     `json:"password"`
	ReplicaUserPassword string     `json:"replica-user-password"`
	SourceNetworks      []string   `json:"source-networks"`
	EnableWebUi         bool       `json:"enable-web-ui"`
	EnableBackup        bool       `json:"enable-backup"`
	BackupWeekdays      []string   `json:"backup-weekdays"`
	BackupTime          string     `json:"backup-time"`
	Port                int        `json:"port"`
	Ipaddress1          string     `json:"ipaddress1"`
	NwMaskLen           int        `json:"nw-mask-len"`
	DefaultRoute        string     `json:"default-route"`
	Name                string     `json:"name"`
	Description         string     `json:"description"`
	Tags                []string   `json:"tags"`
	IconId              sacloud.ID `json:"icon-id"`
	Assumeyes           bool       `json:"assumeyes"`
	ParamTemplate       string     `json:"param-template"`
	ParamTemplateFile   string     `json:"param-template-file"`
	GenerateSkeleton    bool       `json:"generate-skeleton"`
	OutputType          string     `json:"output-type"`
	Column              []string   `json:"column"`
	Quiet               bool       `json:"quiet"`
	Format              string     `json:"format"`
	FormatFile          string     `json:"format-file"`
	Query               string     `json:"query"`
	QueryFile           string     `json:"query-file"`
}

// NewCreateDatabaseParam return new CreateDatabaseParam
func NewCreateDatabaseParam() *CreateDatabaseParam {
	return &CreateDatabaseParam{

		Plan:           10,
		BackupWeekdays: []string{"all"},
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *CreateDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.SwitchId) {
		p.SwitchId = sacloud.ID(0)
	}
	if isEmpty(p.Plan) {
		p.Plan = 0
	}
	if isEmpty(p.Database) {
		p.Database = ""
	}
	if isEmpty(p.Username) {
		p.Username = ""
	}
	if isEmpty(p.Password) {
		p.Password = ""
	}
	if isEmpty(p.ReplicaUserPassword) {
		p.ReplicaUserPassword = ""
	}
	if isEmpty(p.SourceNetworks) {
		p.SourceNetworks = []string{""}
	}
	if isEmpty(p.EnableWebUi) {
		p.EnableWebUi = false
	}
	if isEmpty(p.EnableBackup) {
		p.EnableBackup = false
	}
	if isEmpty(p.BackupWeekdays) {
		p.BackupWeekdays = []string{""}
	}
	if isEmpty(p.BackupTime) {
		p.BackupTime = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.Ipaddress1) {
		p.Ipaddress1 = ""
	}
	if isEmpty(p.NwMaskLen) {
		p.NwMaskLen = 0
	}
	if isEmpty(p.DefaultRoute) {
		p.DefaultRoute = ""
	}
	if isEmpty(p.Name) {
		p.Name = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	if isEmpty(p.Tags) {
		p.Tags = []string{""}
	}
	if isEmpty(p.IconId) {
		p.IconId = sacloud.ID(0)
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}

}

// Validate checks current values in model
func (p *CreateDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--switch-id", p.SwitchId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["switch-id"].ValidateFunc
		errs := validator("--switch-id", p.SwitchId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["plan"].ValidateFunc
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--database", p.Database)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["database"].ValidateFunc
		errs := validator("--database", p.Database)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--username", p.Username)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["username"].ValidateFunc
		errs := validator("--username", p.Username)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--password", p.Password)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["password"].ValidateFunc
		errs := validator("--password", p.Password)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["replica-user-password"].ValidateFunc
		errs := validator("--replica-user-password", p.ReplicaUserPassword)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["source-networks"].ValidateFunc
		errs := validator("--source-networks", p.SourceNetworks)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["backup-weekdays"].ValidateFunc
		errs := validator("--backup-weekdays", p.BackupWeekdays)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["backup-time"].ValidateFunc
		errs := validator("--backup-time", p.BackupTime)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["ipaddress1"].ValidateFunc
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--nw-mask-len", p.NwMaskLen)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["nw-mask-len"].ValidateFunc
		errs := validator("--nw-mask-len", p.NwMaskLen)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--default-route", p.DefaultRoute)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["default-route"].ValidateFunc
		errs := validator("--default-route", p.DefaultRoute)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["create"].Params["icon-id"].ValidateFunc
		errs := validator("--icon-id", p.IconId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *CreateDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *CreateDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["create"]
}

func (p *CreateDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *CreateDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *CreateDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *CreateDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *CreateDatabaseParam) SetSwitchId(v sacloud.ID) {
	p.SwitchId = v
}

func (p *CreateDatabaseParam) GetSwitchId() sacloud.ID {
	return p.SwitchId
}
func (p *CreateDatabaseParam) SetPlan(v int) {
	p.Plan = v
}

func (p *CreateDatabaseParam) GetPlan() int {
	return p.Plan
}
func (p *CreateDatabaseParam) SetDatabase(v string) {
	p.Database = v
}

func (p *CreateDatabaseParam) GetDatabase() string {
	return p.Database
}
func (p *CreateDatabaseParam) SetUsername(v string) {
	p.Username = v
}

func (p *CreateDatabaseParam) GetUsername() string {
	return p.Username
}
func (p *CreateDatabaseParam) SetPassword(v string) {
	p.Password = v
}

func (p *CreateDatabaseParam) GetPassword() string {
	return p.Password
}
func (p *CreateDatabaseParam) SetReplicaUserPassword(v string) {
	p.ReplicaUserPassword = v
}

func (p *CreateDatabaseParam) GetReplicaUserPassword() string {
	return p.ReplicaUserPassword
}
func (p *CreateDatabaseParam) SetSourceNetworks(v []string) {
	p.SourceNetworks = v
}

func (p *CreateDatabaseParam) GetSourceNetworks() []string {
	return p.SourceNetworks
}
func (p *CreateDatabaseParam) SetEnableWebUi(v bool) {
	p.EnableWebUi = v
}

func (p *CreateDatabaseParam) GetEnableWebUi() bool {
	return p.EnableWebUi
}
func (p *CreateDatabaseParam) SetEnableBackup(v bool) {
	p.EnableBackup = v
}

func (p *CreateDatabaseParam) GetEnableBackup() bool {
	return p.EnableBackup
}
func (p *CreateDatabaseParam) SetBackupWeekdays(v []string) {
	p.BackupWeekdays = v
}

func (p *CreateDatabaseParam) GetBackupWeekdays() []string {
	return p.BackupWeekdays
}
func (p *CreateDatabaseParam) SetBackupTime(v string) {
	p.BackupTime = v
}

func (p *CreateDatabaseParam) GetBackupTime() string {
	return p.BackupTime
}
func (p *CreateDatabaseParam) SetPort(v int) {
	p.Port = v
}

func (p *CreateDatabaseParam) GetPort() int {
	return p.Port
}
func (p *CreateDatabaseParam) SetIpaddress1(v string) {
	p.Ipaddress1 = v
}

func (p *CreateDatabaseParam) GetIpaddress1() string {
	return p.Ipaddress1
}
func (p *CreateDatabaseParam) SetNwMaskLen(v int) {
	p.NwMaskLen = v
}

func (p *CreateDatabaseParam) GetNwMaskLen() int {
	return p.NwMaskLen
}
func (p *CreateDatabaseParam) SetDefaultRoute(v string) {
	p.DefaultRoute = v
}

func (p *CreateDatabaseParam) GetDefaultRoute() string {
	return p.DefaultRoute
}
func (p *CreateDatabaseParam) SetName(v string) {
	p.Name = v
}

func (p *CreateDatabaseParam) GetName() string {
	return p.Name
}
func (p *CreateDatabaseParam) SetDescription(v string) {
	p.Description = v
}

func (p *CreateDatabaseParam) GetDescription() string {
	return p.Description
}
func (p *CreateDatabaseParam) SetTags(v []string) {
	p.Tags = v
}

func (p *CreateDatabaseParam) GetTags() []string {
	return p.Tags
}
func (p *CreateDatabaseParam) SetIconId(v sacloud.ID) {
	p.IconId = v
}

func (p *CreateDatabaseParam) GetIconId() sacloud.ID {
	return p.IconId
}
func (p *CreateDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *CreateDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *CreateDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *CreateDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *CreateDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *CreateDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *CreateDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *CreateDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *CreateDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *CreateDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *CreateDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *CreateDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *CreateDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *CreateDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *CreateDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *CreateDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *CreateDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *CreateDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *CreateDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *CreateDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *CreateDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *CreateDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}

// ReadDatabaseParam is input parameters for the sacloud API
type ReadDatabaseParam struct {
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewReadDatabaseParam return new ReadDatabaseParam
func NewReadDatabaseParam() *ReadDatabaseParam {
	return &ReadDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ReadDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *ReadDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ReadDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ReadDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["read"]
}

func (p *ReadDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ReadDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ReadDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ReadDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ReadDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *ReadDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *ReadDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ReadDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ReadDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ReadDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ReadDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ReadDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ReadDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *ReadDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *ReadDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *ReadDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *ReadDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *ReadDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *ReadDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *ReadDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *ReadDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *ReadDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *ReadDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *ReadDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *ReadDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *ReadDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *ReadDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *ReadDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// UpdateDatabaseParam is input parameters for the sacloud API
type UpdateDatabaseParam struct {
	Password            string     `json:"password"`
	ReplicaUserPassword string     `json:"replica-user-password"`
	EnableReplication   bool       `json:"enable-replication"`
	Port                int        `json:"port"`
	SourceNetworks      []string   `json:"source-networks"`
	EnableWebUi         bool       `json:"enable-web-ui"`
	EnableBackup        bool       `json:"enable-backup"`
	BackupWeekdays      []string   `json:"backup-weekdays"`
	BackupTime          string     `json:"backup-time"`
	Selector            []string   `json:"selector"`
	Name                string     `json:"name"`
	Description         string     `json:"description"`
	Tags                []string   `json:"tags"`
	IconId              sacloud.ID `json:"icon-id"`
	Assumeyes           bool       `json:"assumeyes"`
	ParamTemplate       string     `json:"param-template"`
	ParamTemplateFile   string     `json:"param-template-file"`
	GenerateSkeleton    bool       `json:"generate-skeleton"`
	OutputType          string     `json:"output-type"`
	Column              []string   `json:"column"`
	Quiet               bool       `json:"quiet"`
	Format              string     `json:"format"`
	FormatFile          string     `json:"format-file"`
	Query               string     `json:"query"`
	QueryFile           string     `json:"query-file"`
	Id                  sacloud.ID `json:"id"`
}

// NewUpdateDatabaseParam return new UpdateDatabaseParam
func NewUpdateDatabaseParam() *UpdateDatabaseParam {
	return &UpdateDatabaseParam{

		BackupWeekdays: []string{"all"},
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *UpdateDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Password) {
		p.Password = ""
	}
	if isEmpty(p.ReplicaUserPassword) {
		p.ReplicaUserPassword = ""
	}
	if isEmpty(p.EnableReplication) {
		p.EnableReplication = false
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.SourceNetworks) {
		p.SourceNetworks = []string{""}
	}
	if isEmpty(p.EnableWebUi) {
		p.EnableWebUi = false
	}
	if isEmpty(p.EnableBackup) {
		p.EnableBackup = false
	}
	if isEmpty(p.BackupWeekdays) {
		p.BackupWeekdays = []string{""}
	}
	if isEmpty(p.BackupTime) {
		p.BackupTime = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Name) {
		p.Name = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	if isEmpty(p.Tags) {
		p.Tags = []string{""}
	}
	if isEmpty(p.IconId) {
		p.IconId = sacloud.ID(0)
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *UpdateDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["update"].Params["password"].ValidateFunc
		errs := validator("--password", p.Password)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["replica-user-password"].ValidateFunc
		errs := validator("--replica-user-password", p.ReplicaUserPassword)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["source-networks"].ValidateFunc
		errs := validator("--source-networks", p.SourceNetworks)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["backup-weekdays"].ValidateFunc
		errs := validator("--backup-weekdays", p.BackupWeekdays)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["backup-time"].ValidateFunc
		errs := validator("--backup-time", p.BackupTime)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["update"].Params["icon-id"].ValidateFunc
		errs := validator("--icon-id", p.IconId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *UpdateDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *UpdateDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["update"]
}

func (p *UpdateDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *UpdateDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *UpdateDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *UpdateDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *UpdateDatabaseParam) SetPassword(v string) {
	p.Password = v
}

func (p *UpdateDatabaseParam) GetPassword() string {
	return p.Password
}
func (p *UpdateDatabaseParam) SetReplicaUserPassword(v string) {
	p.ReplicaUserPassword = v
}

func (p *UpdateDatabaseParam) GetReplicaUserPassword() string {
	return p.ReplicaUserPassword
}
func (p *UpdateDatabaseParam) SetEnableReplication(v bool) {
	p.EnableReplication = v
}

func (p *UpdateDatabaseParam) GetEnableReplication() bool {
	return p.EnableReplication
}
func (p *UpdateDatabaseParam) SetPort(v int) {
	p.Port = v
}

func (p *UpdateDatabaseParam) GetPort() int {
	return p.Port
}
func (p *UpdateDatabaseParam) SetSourceNetworks(v []string) {
	p.SourceNetworks = v
}

func (p *UpdateDatabaseParam) GetSourceNetworks() []string {
	return p.SourceNetworks
}
func (p *UpdateDatabaseParam) SetEnableWebUi(v bool) {
	p.EnableWebUi = v
}

func (p *UpdateDatabaseParam) GetEnableWebUi() bool {
	return p.EnableWebUi
}
func (p *UpdateDatabaseParam) SetEnableBackup(v bool) {
	p.EnableBackup = v
}

func (p *UpdateDatabaseParam) GetEnableBackup() bool {
	return p.EnableBackup
}
func (p *UpdateDatabaseParam) SetBackupWeekdays(v []string) {
	p.BackupWeekdays = v
}

func (p *UpdateDatabaseParam) GetBackupWeekdays() []string {
	return p.BackupWeekdays
}
func (p *UpdateDatabaseParam) SetBackupTime(v string) {
	p.BackupTime = v
}

func (p *UpdateDatabaseParam) GetBackupTime() string {
	return p.BackupTime
}
func (p *UpdateDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *UpdateDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *UpdateDatabaseParam) SetName(v string) {
	p.Name = v
}

func (p *UpdateDatabaseParam) GetName() string {
	return p.Name
}
func (p *UpdateDatabaseParam) SetDescription(v string) {
	p.Description = v
}

func (p *UpdateDatabaseParam) GetDescription() string {
	return p.Description
}
func (p *UpdateDatabaseParam) SetTags(v []string) {
	p.Tags = v
}

func (p *UpdateDatabaseParam) GetTags() []string {
	return p.Tags
}
func (p *UpdateDatabaseParam) SetIconId(v sacloud.ID) {
	p.IconId = v
}

func (p *UpdateDatabaseParam) GetIconId() sacloud.ID {
	return p.IconId
}
func (p *UpdateDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *UpdateDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *UpdateDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *UpdateDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *UpdateDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *UpdateDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *UpdateDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *UpdateDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *UpdateDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *UpdateDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *UpdateDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *UpdateDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *UpdateDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *UpdateDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *UpdateDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *UpdateDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *UpdateDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *UpdateDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *UpdateDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *UpdateDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *UpdateDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *UpdateDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *UpdateDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *UpdateDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// DeleteDatabaseParam is input parameters for the sacloud API
type DeleteDatabaseParam struct {
	Selector          []string   `json:"selector"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Force             bool       `json:"force"`
	Id                sacloud.ID `json:"id"`
}

// NewDeleteDatabaseParam return new DeleteDatabaseParam
func NewDeleteDatabaseParam() *DeleteDatabaseParam {
	return &DeleteDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *DeleteDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Force) {
		p.Force = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *DeleteDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *DeleteDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *DeleteDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["delete"]
}

func (p *DeleteDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *DeleteDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *DeleteDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *DeleteDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *DeleteDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *DeleteDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *DeleteDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *DeleteDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *DeleteDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *DeleteDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *DeleteDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *DeleteDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *DeleteDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *DeleteDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *DeleteDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *DeleteDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *DeleteDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *DeleteDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *DeleteDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *DeleteDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *DeleteDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *DeleteDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *DeleteDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *DeleteDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *DeleteDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *DeleteDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *DeleteDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *DeleteDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *DeleteDatabaseParam) SetForce(v bool) {
	p.Force = v
}

func (p *DeleteDatabaseParam) GetForce() bool {
	return p.Force
}
func (p *DeleteDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *DeleteDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BootDatabaseParam is input parameters for the sacloud API
type BootDatabaseParam struct {
	Selector          []string   `json:"selector"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewBootDatabaseParam return new BootDatabaseParam
func NewBootDatabaseParam() *BootDatabaseParam {
	return &BootDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BootDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BootDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BootDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BootDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["boot"]
}

func (p *BootDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BootDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BootDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BootDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BootDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *BootDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *BootDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BootDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BootDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BootDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BootDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BootDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BootDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BootDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BootDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BootDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// ShutdownDatabaseParam is input parameters for the sacloud API
type ShutdownDatabaseParam struct {
	Selector          []string   `json:"selector"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewShutdownDatabaseParam return new ShutdownDatabaseParam
func NewShutdownDatabaseParam() *ShutdownDatabaseParam {
	return &ShutdownDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ShutdownDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *ShutdownDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ShutdownDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ShutdownDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["shutdown"]
}

func (p *ShutdownDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ShutdownDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ShutdownDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ShutdownDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ShutdownDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *ShutdownDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *ShutdownDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *ShutdownDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *ShutdownDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ShutdownDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ShutdownDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ShutdownDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ShutdownDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ShutdownDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ShutdownDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *ShutdownDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// ShutdownForceDatabaseParam is input parameters for the sacloud API
type ShutdownForceDatabaseParam struct {
	Selector          []string   `json:"selector"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewShutdownForceDatabaseParam return new ShutdownForceDatabaseParam
func NewShutdownForceDatabaseParam() *ShutdownForceDatabaseParam {
	return &ShutdownForceDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ShutdownForceDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *ShutdownForceDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ShutdownForceDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ShutdownForceDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["shutdown-force"]
}

func (p *ShutdownForceDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ShutdownForceDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ShutdownForceDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ShutdownForceDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ShutdownForceDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *ShutdownForceDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *ShutdownForceDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *ShutdownForceDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *ShutdownForceDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ShutdownForceDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ShutdownForceDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ShutdownForceDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ShutdownForceDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ShutdownForceDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ShutdownForceDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *ShutdownForceDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// ResetDatabaseParam is input parameters for the sacloud API
type ResetDatabaseParam struct {
	Selector          []string   `json:"selector"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewResetDatabaseParam return new ResetDatabaseParam
func NewResetDatabaseParam() *ResetDatabaseParam {
	return &ResetDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ResetDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *ResetDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ResetDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ResetDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["reset"]
}

func (p *ResetDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ResetDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ResetDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ResetDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ResetDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *ResetDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *ResetDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *ResetDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *ResetDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ResetDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ResetDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ResetDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ResetDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ResetDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ResetDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *ResetDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// WaitForBootDatabaseParam is input parameters for the sacloud API
type WaitForBootDatabaseParam struct {
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewWaitForBootDatabaseParam return new WaitForBootDatabaseParam
func NewWaitForBootDatabaseParam() *WaitForBootDatabaseParam {
	return &WaitForBootDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *WaitForBootDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *WaitForBootDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *WaitForBootDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *WaitForBootDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["wait-for-boot"]
}

func (p *WaitForBootDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *WaitForBootDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *WaitForBootDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *WaitForBootDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *WaitForBootDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *WaitForBootDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *WaitForBootDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *WaitForBootDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *WaitForBootDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *WaitForBootDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *WaitForBootDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *WaitForBootDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *WaitForBootDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *WaitForBootDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// WaitForDownDatabaseParam is input parameters for the sacloud API
type WaitForDownDatabaseParam struct {
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewWaitForDownDatabaseParam return new WaitForDownDatabaseParam
func NewWaitForDownDatabaseParam() *WaitForDownDatabaseParam {
	return &WaitForDownDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *WaitForDownDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *WaitForDownDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *WaitForDownDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *WaitForDownDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["wait-for-down"]
}

func (p *WaitForDownDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *WaitForDownDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *WaitForDownDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *WaitForDownDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *WaitForDownDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *WaitForDownDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *WaitForDownDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *WaitForDownDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *WaitForDownDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *WaitForDownDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *WaitForDownDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *WaitForDownDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *WaitForDownDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *WaitForDownDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupInfoDatabaseParam is input parameters for the sacloud API
type BackupInfoDatabaseParam struct {
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupInfoDatabaseParam return new BackupInfoDatabaseParam
func NewBackupInfoDatabaseParam() *BackupInfoDatabaseParam {
	return &BackupInfoDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupInfoDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupInfoDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupInfoDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupInfoDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-info"]
}

func (p *BackupInfoDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupInfoDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupInfoDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupInfoDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupInfoDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *BackupInfoDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *BackupInfoDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupInfoDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupInfoDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupInfoDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupInfoDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupInfoDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupInfoDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupInfoDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupInfoDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupInfoDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupInfoDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupInfoDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupInfoDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupInfoDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupInfoDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupInfoDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupInfoDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupInfoDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupInfoDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupInfoDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupInfoDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupInfoDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupCreateDatabaseParam is input parameters for the sacloud API
type BackupCreateDatabaseParam struct {
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupCreateDatabaseParam return new BackupCreateDatabaseParam
func NewBackupCreateDatabaseParam() *BackupCreateDatabaseParam {
	return &BackupCreateDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupCreateDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupCreateDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupCreateDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupCreateDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-create"]
}

func (p *BackupCreateDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupCreateDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupCreateDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupCreateDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupCreateDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BackupCreateDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BackupCreateDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupCreateDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupCreateDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupCreateDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupCreateDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupCreateDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupCreateDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupCreateDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupCreateDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupCreateDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupCreateDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupCreateDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupCreateDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupCreateDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupCreateDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupCreateDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupCreateDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupCreateDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupCreateDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupCreateDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupCreateDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupCreateDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupRestoreDatabaseParam is input parameters for the sacloud API
type BackupRestoreDatabaseParam struct {
	Index             int        `json:"index"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupRestoreDatabaseParam return new BackupRestoreDatabaseParam
func NewBackupRestoreDatabaseParam() *BackupRestoreDatabaseParam {
	return &BackupRestoreDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupRestoreDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupRestoreDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["backup-restore"].Params["index"].ValidateFunc
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupRestoreDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupRestoreDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-restore"]
}

func (p *BackupRestoreDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupRestoreDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupRestoreDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupRestoreDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupRestoreDatabaseParam) SetIndex(v int) {
	p.Index = v
}

func (p *BackupRestoreDatabaseParam) GetIndex() int {
	return p.Index
}
func (p *BackupRestoreDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BackupRestoreDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BackupRestoreDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupRestoreDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupRestoreDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupRestoreDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupRestoreDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupRestoreDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupRestoreDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupRestoreDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupRestoreDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupRestoreDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupRestoreDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupRestoreDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupRestoreDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupRestoreDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupRestoreDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupRestoreDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupRestoreDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupRestoreDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupRestoreDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupRestoreDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupRestoreDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupRestoreDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupLockDatabaseParam is input parameters for the sacloud API
type BackupLockDatabaseParam struct {
	Index             int        `json:"index"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupLockDatabaseParam return new BackupLockDatabaseParam
func NewBackupLockDatabaseParam() *BackupLockDatabaseParam {
	return &BackupLockDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupLockDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupLockDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["backup-lock"].Params["index"].ValidateFunc
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupLockDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupLockDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-lock"]
}

func (p *BackupLockDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupLockDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupLockDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupLockDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupLockDatabaseParam) SetIndex(v int) {
	p.Index = v
}

func (p *BackupLockDatabaseParam) GetIndex() int {
	return p.Index
}
func (p *BackupLockDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BackupLockDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BackupLockDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupLockDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupLockDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupLockDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupLockDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupLockDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupLockDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupLockDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupLockDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupLockDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupLockDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupLockDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupLockDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupLockDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupLockDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupLockDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupLockDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupLockDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupLockDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupLockDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupLockDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupLockDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupUnlockDatabaseParam is input parameters for the sacloud API
type BackupUnlockDatabaseParam struct {
	Index             int        `json:"index"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupUnlockDatabaseParam return new BackupUnlockDatabaseParam
func NewBackupUnlockDatabaseParam() *BackupUnlockDatabaseParam {
	return &BackupUnlockDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupUnlockDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupUnlockDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["backup-unlock"].Params["index"].ValidateFunc
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupUnlockDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupUnlockDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-unlock"]
}

func (p *BackupUnlockDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupUnlockDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupUnlockDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupUnlockDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupUnlockDatabaseParam) SetIndex(v int) {
	p.Index = v
}

func (p *BackupUnlockDatabaseParam) GetIndex() int {
	return p.Index
}
func (p *BackupUnlockDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BackupUnlockDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BackupUnlockDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupUnlockDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupUnlockDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupUnlockDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupUnlockDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupUnlockDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupUnlockDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupUnlockDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupUnlockDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupUnlockDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupUnlockDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupUnlockDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupUnlockDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupUnlockDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupUnlockDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupUnlockDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupUnlockDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupUnlockDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupUnlockDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupUnlockDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupUnlockDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupUnlockDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// BackupRemoveDatabaseParam is input parameters for the sacloud API
type BackupRemoveDatabaseParam struct {
	Index             int        `json:"index"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewBackupRemoveDatabaseParam return new BackupRemoveDatabaseParam
func NewBackupRemoveDatabaseParam() *BackupRemoveDatabaseParam {
	return &BackupRemoveDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BackupRemoveDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *BackupRemoveDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["backup-remove"].Params["index"].ValidateFunc
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *BackupRemoveDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *BackupRemoveDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["backup-remove"]
}

func (p *BackupRemoveDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *BackupRemoveDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *BackupRemoveDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *BackupRemoveDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *BackupRemoveDatabaseParam) SetIndex(v int) {
	p.Index = v
}

func (p *BackupRemoveDatabaseParam) GetIndex() int {
	return p.Index
}
func (p *BackupRemoveDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *BackupRemoveDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *BackupRemoveDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *BackupRemoveDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *BackupRemoveDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *BackupRemoveDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *BackupRemoveDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *BackupRemoveDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *BackupRemoveDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *BackupRemoveDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *BackupRemoveDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *BackupRemoveDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *BackupRemoveDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *BackupRemoveDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *BackupRemoveDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *BackupRemoveDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *BackupRemoveDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *BackupRemoveDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *BackupRemoveDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *BackupRemoveDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *BackupRemoveDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *BackupRemoveDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *BackupRemoveDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *BackupRemoveDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// CloneDatabaseParam is input parameters for the sacloud API
type CloneDatabaseParam struct {
	Port                int        `json:"port"`
	SwitchId            sacloud.ID `json:"switch-id"`
	Ipaddress1          string     `json:"ipaddress1"`
	Plan                int        `json:"plan"`
	NwMaskLen           int        `json:"nw-mask-len"`
	DefaultRoute        string     `json:"default-route"`
	ReplicaUserPassword string     `json:"replica-user-password"`
	SourceNetworks      []string   `json:"source-networks"`
	EnableWebUi         bool       `json:"enable-web-ui"`
	EnableBackup        bool       `json:"enable-backup"`
	BackupWeekdays      []string   `json:"backup-weekdays"`
	BackupTime          string     `json:"backup-time"`
	Name                string     `json:"name"`
	Description         string     `json:"description"`
	Tags                []string   `json:"tags"`
	IconId              sacloud.ID `json:"icon-id"`
	Assumeyes           bool       `json:"assumeyes"`
	ParamTemplate       string     `json:"param-template"`
	ParamTemplateFile   string     `json:"param-template-file"`
	GenerateSkeleton    bool       `json:"generate-skeleton"`
	OutputType          string     `json:"output-type"`
	Column              []string   `json:"column"`
	Quiet               bool       `json:"quiet"`
	Format              string     `json:"format"`
	FormatFile          string     `json:"format-file"`
	Query               string     `json:"query"`
	QueryFile           string     `json:"query-file"`
	Id                  sacloud.ID `json:"id"`
}

// NewCloneDatabaseParam return new CloneDatabaseParam
func NewCloneDatabaseParam() *CloneDatabaseParam {
	return &CloneDatabaseParam{

		Plan:           10,
		BackupWeekdays: []string{"all"},
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *CloneDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.SwitchId) {
		p.SwitchId = sacloud.ID(0)
	}
	if isEmpty(p.Ipaddress1) {
		p.Ipaddress1 = ""
	}
	if isEmpty(p.Plan) {
		p.Plan = 0
	}
	if isEmpty(p.NwMaskLen) {
		p.NwMaskLen = 0
	}
	if isEmpty(p.DefaultRoute) {
		p.DefaultRoute = ""
	}
	if isEmpty(p.ReplicaUserPassword) {
		p.ReplicaUserPassword = ""
	}
	if isEmpty(p.SourceNetworks) {
		p.SourceNetworks = []string{""}
	}
	if isEmpty(p.EnableWebUi) {
		p.EnableWebUi = false
	}
	if isEmpty(p.EnableBackup) {
		p.EnableBackup = false
	}
	if isEmpty(p.BackupWeekdays) {
		p.BackupWeekdays = []string{""}
	}
	if isEmpty(p.BackupTime) {
		p.BackupTime = ""
	}
	if isEmpty(p.Name) {
		p.Name = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	if isEmpty(p.Tags) {
		p.Tags = []string{""}
	}
	if isEmpty(p.IconId) {
		p.IconId = sacloud.ID(0)
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *CloneDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["switch-id"].ValidateFunc
		errs := validator("--switch-id", p.SwitchId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["ipaddress1"].ValidateFunc
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["plan"].ValidateFunc
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["nw-mask-len"].ValidateFunc
		errs := validator("--nw-mask-len", p.NwMaskLen)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["default-route"].ValidateFunc
		errs := validator("--default-route", p.DefaultRoute)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["replica-user-password"].ValidateFunc
		errs := validator("--replica-user-password", p.ReplicaUserPassword)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["source-networks"].ValidateFunc
		errs := validator("--source-networks", p.SourceNetworks)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["backup-weekdays"].ValidateFunc
		errs := validator("--backup-weekdays", p.BackupWeekdays)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["backup-time"].ValidateFunc
		errs := validator("--backup-time", p.BackupTime)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["clone"].Params["icon-id"].ValidateFunc
		errs := validator("--icon-id", p.IconId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *CloneDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *CloneDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["clone"]
}

func (p *CloneDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *CloneDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *CloneDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *CloneDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *CloneDatabaseParam) SetPort(v int) {
	p.Port = v
}

func (p *CloneDatabaseParam) GetPort() int {
	return p.Port
}
func (p *CloneDatabaseParam) SetSwitchId(v sacloud.ID) {
	p.SwitchId = v
}

func (p *CloneDatabaseParam) GetSwitchId() sacloud.ID {
	return p.SwitchId
}
func (p *CloneDatabaseParam) SetIpaddress1(v string) {
	p.Ipaddress1 = v
}

func (p *CloneDatabaseParam) GetIpaddress1() string {
	return p.Ipaddress1
}
func (p *CloneDatabaseParam) SetPlan(v int) {
	p.Plan = v
}

func (p *CloneDatabaseParam) GetPlan() int {
	return p.Plan
}
func (p *CloneDatabaseParam) SetNwMaskLen(v int) {
	p.NwMaskLen = v
}

func (p *CloneDatabaseParam) GetNwMaskLen() int {
	return p.NwMaskLen
}
func (p *CloneDatabaseParam) SetDefaultRoute(v string) {
	p.DefaultRoute = v
}

func (p *CloneDatabaseParam) GetDefaultRoute() string {
	return p.DefaultRoute
}
func (p *CloneDatabaseParam) SetReplicaUserPassword(v string) {
	p.ReplicaUserPassword = v
}

func (p *CloneDatabaseParam) GetReplicaUserPassword() string {
	return p.ReplicaUserPassword
}
func (p *CloneDatabaseParam) SetSourceNetworks(v []string) {
	p.SourceNetworks = v
}

func (p *CloneDatabaseParam) GetSourceNetworks() []string {
	return p.SourceNetworks
}
func (p *CloneDatabaseParam) SetEnableWebUi(v bool) {
	p.EnableWebUi = v
}

func (p *CloneDatabaseParam) GetEnableWebUi() bool {
	return p.EnableWebUi
}
func (p *CloneDatabaseParam) SetEnableBackup(v bool) {
	p.EnableBackup = v
}

func (p *CloneDatabaseParam) GetEnableBackup() bool {
	return p.EnableBackup
}
func (p *CloneDatabaseParam) SetBackupWeekdays(v []string) {
	p.BackupWeekdays = v
}

func (p *CloneDatabaseParam) GetBackupWeekdays() []string {
	return p.BackupWeekdays
}
func (p *CloneDatabaseParam) SetBackupTime(v string) {
	p.BackupTime = v
}

func (p *CloneDatabaseParam) GetBackupTime() string {
	return p.BackupTime
}
func (p *CloneDatabaseParam) SetName(v string) {
	p.Name = v
}

func (p *CloneDatabaseParam) GetName() string {
	return p.Name
}
func (p *CloneDatabaseParam) SetDescription(v string) {
	p.Description = v
}

func (p *CloneDatabaseParam) GetDescription() string {
	return p.Description
}
func (p *CloneDatabaseParam) SetTags(v []string) {
	p.Tags = v
}

func (p *CloneDatabaseParam) GetTags() []string {
	return p.Tags
}
func (p *CloneDatabaseParam) SetIconId(v sacloud.ID) {
	p.IconId = v
}

func (p *CloneDatabaseParam) GetIconId() sacloud.ID {
	return p.IconId
}
func (p *CloneDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *CloneDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *CloneDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *CloneDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *CloneDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *CloneDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *CloneDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *CloneDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *CloneDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *CloneDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *CloneDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *CloneDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *CloneDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *CloneDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *CloneDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *CloneDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *CloneDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *CloneDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *CloneDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *CloneDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *CloneDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *CloneDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *CloneDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *CloneDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// ReplicaCreateDatabaseParam is input parameters for the sacloud API
type ReplicaCreateDatabaseParam struct {
	SwitchId          sacloud.ID `json:"switch-id"`
	Ipaddress1        string     `json:"ipaddress1"`
	NwMaskLen         int        `json:"nw-mask-len"`
	DefaultRoute      string     `json:"default-route"`
	Name              string     `json:"name"`
	Description       string     `json:"description"`
	Tags              []string   `json:"tags"`
	IconId            sacloud.ID `json:"icon-id"`
	Assumeyes         bool       `json:"assumeyes"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewReplicaCreateDatabaseParam return new ReplicaCreateDatabaseParam
func NewReplicaCreateDatabaseParam() *ReplicaCreateDatabaseParam {
	return &ReplicaCreateDatabaseParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ReplicaCreateDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.SwitchId) {
		p.SwitchId = sacloud.ID(0)
	}
	if isEmpty(p.Ipaddress1) {
		p.Ipaddress1 = ""
	}
	if isEmpty(p.NwMaskLen) {
		p.NwMaskLen = 0
	}
	if isEmpty(p.DefaultRoute) {
		p.DefaultRoute = ""
	}
	if isEmpty(p.Name) {
		p.Name = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	if isEmpty(p.Tags) {
		p.Tags = []string{""}
	}
	if isEmpty(p.IconId) {
		p.IconId = sacloud.ID(0)
	}
	if isEmpty(p.Assumeyes) {
		p.Assumeyes = false
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *ReplicaCreateDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["switch-id"].ValidateFunc
		errs := validator("--switch-id", p.SwitchId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["ipaddress1"].ValidateFunc
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["nw-mask-len"].ValidateFunc
		errs := validator("--nw-mask-len", p.NwMaskLen)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["default-route"].ValidateFunc
		errs := validator("--default-route", p.DefaultRoute)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["replica-create"].Params["icon-id"].ValidateFunc
		errs := validator("--icon-id", p.IconId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *ReplicaCreateDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *ReplicaCreateDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["replica-create"]
}

func (p *ReplicaCreateDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *ReplicaCreateDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *ReplicaCreateDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *ReplicaCreateDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *ReplicaCreateDatabaseParam) SetSwitchId(v sacloud.ID) {
	p.SwitchId = v
}

func (p *ReplicaCreateDatabaseParam) GetSwitchId() sacloud.ID {
	return p.SwitchId
}
func (p *ReplicaCreateDatabaseParam) SetIpaddress1(v string) {
	p.Ipaddress1 = v
}

func (p *ReplicaCreateDatabaseParam) GetIpaddress1() string {
	return p.Ipaddress1
}
func (p *ReplicaCreateDatabaseParam) SetNwMaskLen(v int) {
	p.NwMaskLen = v
}

func (p *ReplicaCreateDatabaseParam) GetNwMaskLen() int {
	return p.NwMaskLen
}
func (p *ReplicaCreateDatabaseParam) SetDefaultRoute(v string) {
	p.DefaultRoute = v
}

func (p *ReplicaCreateDatabaseParam) GetDefaultRoute() string {
	return p.DefaultRoute
}
func (p *ReplicaCreateDatabaseParam) SetName(v string) {
	p.Name = v
}

func (p *ReplicaCreateDatabaseParam) GetName() string {
	return p.Name
}
func (p *ReplicaCreateDatabaseParam) SetDescription(v string) {
	p.Description = v
}

func (p *ReplicaCreateDatabaseParam) GetDescription() string {
	return p.Description
}
func (p *ReplicaCreateDatabaseParam) SetTags(v []string) {
	p.Tags = v
}

func (p *ReplicaCreateDatabaseParam) GetTags() []string {
	return p.Tags
}
func (p *ReplicaCreateDatabaseParam) SetIconId(v sacloud.ID) {
	p.IconId = v
}

func (p *ReplicaCreateDatabaseParam) GetIconId() sacloud.ID {
	return p.IconId
}
func (p *ReplicaCreateDatabaseParam) SetAssumeyes(v bool) {
	p.Assumeyes = v
}

func (p *ReplicaCreateDatabaseParam) GetAssumeyes() bool {
	return p.Assumeyes
}
func (p *ReplicaCreateDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *ReplicaCreateDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *ReplicaCreateDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *ReplicaCreateDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *ReplicaCreateDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *ReplicaCreateDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *ReplicaCreateDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *ReplicaCreateDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *ReplicaCreateDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *ReplicaCreateDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *ReplicaCreateDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *ReplicaCreateDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *ReplicaCreateDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *ReplicaCreateDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *ReplicaCreateDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *ReplicaCreateDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *ReplicaCreateDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *ReplicaCreateDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *ReplicaCreateDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *ReplicaCreateDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *ReplicaCreateDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *ReplicaCreateDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorCpuDatabaseParam is input parameters for the sacloud API
type MonitorCpuDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorCpuDatabaseParam return new MonitorCpuDatabaseParam
func NewMonitorCpuDatabaseParam() *MonitorCpuDatabaseParam {
	return &MonitorCpuDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.cpu",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorCpuDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorCpuDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-cpu"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-cpu"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorCpuDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorCpuDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-cpu"]
}

func (p *MonitorCpuDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorCpuDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorCpuDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorCpuDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorCpuDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorCpuDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorCpuDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorCpuDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorCpuDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorCpuDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorCpuDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorCpuDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorCpuDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorCpuDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorCpuDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorCpuDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorCpuDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorCpuDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorCpuDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorCpuDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorCpuDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorCpuDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorCpuDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorCpuDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorCpuDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorCpuDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorCpuDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorCpuDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorCpuDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorCpuDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorCpuDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorCpuDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorCpuDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorCpuDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorMemoryDatabaseParam is input parameters for the sacloud API
type MonitorMemoryDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorMemoryDatabaseParam return new MonitorMemoryDatabaseParam
func NewMonitorMemoryDatabaseParam() *MonitorMemoryDatabaseParam {
	return &MonitorMemoryDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.memory",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorMemoryDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorMemoryDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-memory"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-memory"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorMemoryDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorMemoryDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-memory"]
}

func (p *MonitorMemoryDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorMemoryDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorMemoryDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorMemoryDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorMemoryDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorMemoryDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorMemoryDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorMemoryDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorMemoryDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorMemoryDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorMemoryDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorMemoryDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorMemoryDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorMemoryDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorMemoryDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorMemoryDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorMemoryDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorMemoryDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorMemoryDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorMemoryDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorMemoryDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorMemoryDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorMemoryDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorMemoryDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorMemoryDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorMemoryDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorMemoryDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorMemoryDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorMemoryDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorMemoryDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorMemoryDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorMemoryDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorMemoryDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorMemoryDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorNicDatabaseParam is input parameters for the sacloud API
type MonitorNicDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorNicDatabaseParam return new MonitorNicDatabaseParam
func NewMonitorNicDatabaseParam() *MonitorNicDatabaseParam {
	return &MonitorNicDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.nic",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorNicDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorNicDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-nic"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-nic"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorNicDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorNicDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-nic"]
}

func (p *MonitorNicDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorNicDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorNicDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorNicDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorNicDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorNicDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorNicDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorNicDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorNicDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorNicDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorNicDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorNicDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorNicDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorNicDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorNicDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorNicDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorNicDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorNicDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorNicDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorNicDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorNicDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorNicDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorNicDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorNicDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorNicDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorNicDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorNicDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorNicDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorNicDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorNicDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorNicDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorNicDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorNicDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorNicDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorSystemDiskDatabaseParam is input parameters for the sacloud API
type MonitorSystemDiskDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorSystemDiskDatabaseParam return new MonitorSystemDiskDatabaseParam
func NewMonitorSystemDiskDatabaseParam() *MonitorSystemDiskDatabaseParam {
	return &MonitorSystemDiskDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.disk1",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorSystemDiskDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorSystemDiskDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-system-disk"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-system-disk"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorSystemDiskDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorSystemDiskDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-system-disk"]
}

func (p *MonitorSystemDiskDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorSystemDiskDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorSystemDiskDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorSystemDiskDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorSystemDiskDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorSystemDiskDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorSystemDiskDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorSystemDiskDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorSystemDiskDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorSystemDiskDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorSystemDiskDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorSystemDiskDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorSystemDiskDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorSystemDiskDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorSystemDiskDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorSystemDiskDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorSystemDiskDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorSystemDiskDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorSystemDiskDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorSystemDiskDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorSystemDiskDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorSystemDiskDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorSystemDiskDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorSystemDiskDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorSystemDiskDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorSystemDiskDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorSystemDiskDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorSystemDiskDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorSystemDiskDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorSystemDiskDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorSystemDiskDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorSystemDiskDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorSystemDiskDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorSystemDiskDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorBackupDiskDatabaseParam is input parameters for the sacloud API
type MonitorBackupDiskDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorBackupDiskDatabaseParam return new MonitorBackupDiskDatabaseParam
func NewMonitorBackupDiskDatabaseParam() *MonitorBackupDiskDatabaseParam {
	return &MonitorBackupDiskDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.disk2",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorBackupDiskDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorBackupDiskDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-backup-disk"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-backup-disk"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorBackupDiskDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorBackupDiskDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-backup-disk"]
}

func (p *MonitorBackupDiskDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorBackupDiskDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorBackupDiskDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorBackupDiskDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorBackupDiskDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorBackupDiskDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorBackupDiskDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorBackupDiskDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorBackupDiskDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorBackupDiskDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorBackupDiskDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorBackupDiskDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorBackupDiskDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorBackupDiskDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorBackupDiskDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorBackupDiskDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorBackupDiskDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorBackupDiskDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorBackupDiskDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorBackupDiskDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorBackupDiskDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorBackupDiskDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorBackupDiskDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorBackupDiskDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorBackupDiskDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorBackupDiskDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorBackupDiskDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorBackupDiskDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorBackupDiskDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorBackupDiskDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorBackupDiskDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorBackupDiskDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorBackupDiskDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorBackupDiskDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorSystemDiskSizeDatabaseParam is input parameters for the sacloud API
type MonitorSystemDiskSizeDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorSystemDiskSizeDatabaseParam return new MonitorSystemDiskSizeDatabaseParam
func NewMonitorSystemDiskSizeDatabaseParam() *MonitorSystemDiskSizeDatabaseParam {
	return &MonitorSystemDiskSizeDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.disk1",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorSystemDiskSizeDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorSystemDiskSizeDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-system-disk-size"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-system-disk-size"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-system-disk-size"]
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorSystemDiskSizeDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorSystemDiskSizeDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorSystemDiskSizeDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// MonitorBackupDiskSizeDatabaseParam is input parameters for the sacloud API
type MonitorBackupDiskSizeDatabaseParam struct {
	Start             string     `json:"start"`
	End               string     `json:"end"`
	KeyFormat         string     `json:"key-format"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	OutputType        string     `json:"output-type"`
	Column            []string   `json:"column"`
	Quiet             bool       `json:"quiet"`
	Format            string     `json:"format"`
	FormatFile        string     `json:"format-file"`
	Query             string     `json:"query"`
	QueryFile         string     `json:"query-file"`
	Id                sacloud.ID `json:"id"`
}

// NewMonitorBackupDiskSizeDatabaseParam return new MonitorBackupDiskSizeDatabaseParam
func NewMonitorBackupDiskSizeDatabaseParam() *MonitorBackupDiskSizeDatabaseParam {
	return &MonitorBackupDiskSizeDatabaseParam{

		KeyFormat: "sakuracloud.database.{{.ID}}.disk2",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *MonitorBackupDiskSizeDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.Start) {
		p.Start = ""
	}
	if isEmpty(p.End) {
		p.End = ""
	}
	if isEmpty(p.KeyFormat) {
		p.KeyFormat = ""
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.OutputType) {
		p.OutputType = ""
	}
	if isEmpty(p.Column) {
		p.Column = []string{""}
	}
	if isEmpty(p.Quiet) {
		p.Quiet = false
	}
	if isEmpty(p.Format) {
		p.Format = ""
	}
	if isEmpty(p.FormatFile) {
		p.FormatFile = ""
	}
	if isEmpty(p.Query) {
		p.Query = ""
	}
	if isEmpty(p.QueryFile) {
		p.QueryFile = ""
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *MonitorBackupDiskSizeDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["monitor-backup-disk-size"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["Database"].Commands["monitor-backup-disk-size"].Params["end"].ValidateFunc
		errs := validator("--end", p.End)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--key-format", p.KeyFormat)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	{
		validator := schema.ValidateInStrValues(define.AllowOutputTypes...)
		errs := validator("--output-type", p.OutputType)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateInputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateOutputOption(p)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["monitor-backup-disk-size"]
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *MonitorBackupDiskSizeDatabaseParam) SetStart(v string) {
	p.Start = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetStart() string {
	return p.Start
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetEnd(v string) {
	p.End = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetEnd() string {
	return p.End
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetKeyFormat(v string) {
	p.KeyFormat = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetKeyFormat() string {
	return p.KeyFormat
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetOutputType(v string) {
	p.OutputType = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetOutputType() string {
	return p.OutputType
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetColumn(v []string) {
	p.Column = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetColumn() []string {
	return p.Column
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetQuiet(v bool) {
	p.Quiet = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetQuiet() bool {
	return p.Quiet
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetFormat(v string) {
	p.Format = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetFormat() string {
	return p.Format
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetFormatFile(v string) {
	p.FormatFile = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetFormatFile() string {
	return p.FormatFile
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetQuery(v string) {
	p.Query = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetQuery() string {
	return p.Query
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetQueryFile(v string) {
	p.QueryFile = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetQueryFile() string {
	return p.QueryFile
}
func (p *MonitorBackupDiskSizeDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *MonitorBackupDiskSizeDatabaseParam) GetId() sacloud.ID {
	return p.Id
}

// LogsDatabaseParam is input parameters for the sacloud API
type LogsDatabaseParam struct {
	LogName           string     `json:"log-name"`
	Follow            bool       `json:"follow"`
	RefreshInterval   sacloud.ID `json:"refresh-interval"`
	ListLogNames      bool       `json:"list-log-names"`
	Selector          []string   `json:"selector"`
	ParamTemplate     string     `json:"param-template"`
	ParamTemplateFile string     `json:"param-template-file"`
	GenerateSkeleton  bool       `json:"generate-skeleton"`
	Id                sacloud.ID `json:"id"`
}

// NewLogsDatabaseParam return new LogsDatabaseParam
func NewLogsDatabaseParam() *LogsDatabaseParam {
	return &LogsDatabaseParam{

		LogName:         "all",
		RefreshInterval: 3,
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *LogsDatabaseParam) FillValueToSkeleton() {
	if isEmpty(p.LogName) {
		p.LogName = ""
	}
	if isEmpty(p.Follow) {
		p.Follow = false
	}
	if isEmpty(p.RefreshInterval) {
		p.RefreshInterval = sacloud.ID(0)
	}
	if isEmpty(p.ListLogNames) {
		p.ListLogNames = false
	}
	if isEmpty(p.Selector) {
		p.Selector = []string{""}
	}
	if isEmpty(p.ParamTemplate) {
		p.ParamTemplate = ""
	}
	if isEmpty(p.ParamTemplateFile) {
		p.ParamTemplateFile = ""
	}
	if isEmpty(p.GenerateSkeleton) {
		p.GenerateSkeleton = false
	}
	if isEmpty(p.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *LogsDatabaseParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["Database"].Commands["logs"].Params["refresh-interval"].ValidateFunc
		errs := validator("--refresh-interval", p.RefreshInterval)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

func (p *LogsDatabaseParam) GetResourceDef() *schema.Resource {
	return define.Resources["Database"]
}

func (p *LogsDatabaseParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["logs"]
}

func (p *LogsDatabaseParam) GetIncludeFields() []string {
	return p.GetCommandDef().IncludeFields
}

func (p *LogsDatabaseParam) GetExcludeFields() []string {
	return p.GetCommandDef().ExcludeFields
}

func (p *LogsDatabaseParam) GetTableType() output.TableType {
	return p.GetCommandDef().TableType
}

func (p *LogsDatabaseParam) GetColumnDefs() []output.ColumnDef {
	return p.GetCommandDef().TableColumnDefines
}

func (p *LogsDatabaseParam) SetLogName(v string) {
	p.LogName = v
}

func (p *LogsDatabaseParam) GetLogName() string {
	return p.LogName
}
func (p *LogsDatabaseParam) SetFollow(v bool) {
	p.Follow = v
}

func (p *LogsDatabaseParam) GetFollow() bool {
	return p.Follow
}
func (p *LogsDatabaseParam) SetRefreshInterval(v sacloud.ID) {
	p.RefreshInterval = v
}

func (p *LogsDatabaseParam) GetRefreshInterval() sacloud.ID {
	return p.RefreshInterval
}
func (p *LogsDatabaseParam) SetListLogNames(v bool) {
	p.ListLogNames = v
}

func (p *LogsDatabaseParam) GetListLogNames() bool {
	return p.ListLogNames
}
func (p *LogsDatabaseParam) SetSelector(v []string) {
	p.Selector = v
}

func (p *LogsDatabaseParam) GetSelector() []string {
	return p.Selector
}
func (p *LogsDatabaseParam) SetParamTemplate(v string) {
	p.ParamTemplate = v
}

func (p *LogsDatabaseParam) GetParamTemplate() string {
	return p.ParamTemplate
}
func (p *LogsDatabaseParam) SetParamTemplateFile(v string) {
	p.ParamTemplateFile = v
}

func (p *LogsDatabaseParam) GetParamTemplateFile() string {
	return p.ParamTemplateFile
}
func (p *LogsDatabaseParam) SetGenerateSkeleton(v bool) {
	p.GenerateSkeleton = v
}

func (p *LogsDatabaseParam) GetGenerateSkeleton() bool {
	return p.GenerateSkeleton
}
func (p *LogsDatabaseParam) SetId(v sacloud.ID) {
	p.Id = v
}

func (p *LogsDatabaseParam) GetId() sacloud.ID {
	return p.Id
}