params_load_balancer_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"
)

// ListLoadBalancerParam is input parameters for the sacloud API
type ListLoadBalancerParam 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"`
}

// NewListLoadBalancerParam return new ListLoadBalancerParam
func NewListLoadBalancerParam() *ListLoadBalancerParam {
	return &ListLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ListLoadBalancerParam) 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 *ListLoadBalancerParam) 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["LoadBalancer"].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["LoadBalancer"].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 *ListLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// CreateLoadBalancerParam is input parameters for the sacloud API
type CreateLoadBalancerParam struct {
	SwitchId          sacloud.ID `json:"switch-id"`
	Vrid              int        `json:"vrid"`
	HighAvailability  bool       `json:"high-availability"`
	Plan              string     `json:"plan"`
	Ipaddress1        string     `json:"ipaddress1"`
	Ipaddress2        string     `json:"ipaddress2"`
	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"`
}

// NewCreateLoadBalancerParam return new CreateLoadBalancerParam
func NewCreateLoadBalancerParam() *CreateLoadBalancerParam {
	return &CreateLoadBalancerParam{

		Vrid: 1,
		Plan: "standard",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *CreateLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.SwitchId) {
		p.SwitchId = sacloud.ID(0)
	}
	if isEmpty(p.Vrid) {
		p.Vrid = 0
	}
	if isEmpty(p.HighAvailability) {
		p.HighAvailability = false
	}
	if isEmpty(p.Plan) {
		p.Plan = ""
	}
	if isEmpty(p.Ipaddress1) {
		p.Ipaddress1 = ""
	}
	if isEmpty(p.Ipaddress2) {
		p.Ipaddress2 = ""
	}
	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 *CreateLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["switch-id"].ValidateFunc
		errs := validator("--switch-id", p.SwitchId)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--vrid", p.Vrid)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["plan"].ValidateFunc
		errs := validator("--plan", p.Plan)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["ipaddress1"].ValidateFunc
		errs := validator("--ipaddress1", p.Ipaddress1)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["ipaddress2"].ValidateFunc
		errs := validator("--ipaddress2", p.Ipaddress2)
		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["LoadBalancer"].Commands["create"].Params["nw-mask-len"].ValidateFunc
		errs := validator("--nw-mask-len", p.NwMaskLen)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].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["LoadBalancer"].Commands["create"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["create"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].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 *CreateLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

func (p *CreateLoadBalancerParam) GetSwitchId() sacloud.ID {
	return p.SwitchId
}
func (p *CreateLoadBalancerParam) SetVrid(v int) {
	p.Vrid = v
}

func (p *CreateLoadBalancerParam) GetVrid() int {
	return p.Vrid
}
func (p *CreateLoadBalancerParam) SetHighAvailability(v bool) {
	p.HighAvailability = v
}

func (p *CreateLoadBalancerParam) GetHighAvailability() bool {
	return p.HighAvailability
}
func (p *CreateLoadBalancerParam) SetPlan(v string) {
	p.Plan = v
}

func (p *CreateLoadBalancerParam) GetPlan() string {
	return p.Plan
}
func (p *CreateLoadBalancerParam) SetIpaddress1(v string) {
	p.Ipaddress1 = v
}

func (p *CreateLoadBalancerParam) GetIpaddress1() string {
	return p.Ipaddress1
}
func (p *CreateLoadBalancerParam) SetIpaddress2(v string) {
	p.Ipaddress2 = v
}

func (p *CreateLoadBalancerParam) GetIpaddress2() string {
	return p.Ipaddress2
}
func (p *CreateLoadBalancerParam) SetNwMaskLen(v int) {
	p.NwMaskLen = v
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// ReadLoadBalancerParam is input parameters for the sacloud API
type ReadLoadBalancerParam 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"`
}

// NewReadLoadBalancerParam return new ReadLoadBalancerParam
func NewReadLoadBalancerParam() *ReadLoadBalancerParam {
	return &ReadLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ReadLoadBalancerParam) 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 *ReadLoadBalancerParam) 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 *ReadLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// UpdateLoadBalancerParam is input parameters for the sacloud API
type UpdateLoadBalancerParam struct {
	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"`
}

// NewUpdateLoadBalancerParam return new UpdateLoadBalancerParam
func NewUpdateLoadBalancerParam() *UpdateLoadBalancerParam {
	return &UpdateLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *UpdateLoadBalancerParam) FillValueToSkeleton() {
	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 *UpdateLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["LoadBalancer"].Commands["update"].Params["name"].ValidateFunc
		errs := validator("--name", p.Name)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["update"].Params["description"].ValidateFunc
		errs := validator("--description", p.Description)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["update"].Params["tags"].ValidateFunc
		errs := validator("--tags", p.Tags)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].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 *UpdateLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// DeleteLoadBalancerParam is input parameters for the sacloud API
type DeleteLoadBalancerParam struct {
	Force             bool       `json:"force"`
	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"`
	Id                sacloud.ID `json:"id"`
}

// NewDeleteLoadBalancerParam return new DeleteLoadBalancerParam
func NewDeleteLoadBalancerParam() *DeleteLoadBalancerParam {
	return &DeleteLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *DeleteLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.Force) {
		p.Force = false
	}
	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.Id) {
		p.Id = sacloud.ID(0)
	}

}

// Validate checks current values in model
func (p *DeleteLoadBalancerParam) 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 *DeleteLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

func (p *DeleteLoadBalancerParam) SetForce(v bool) {
	p.Force = v
}

func (p *DeleteLoadBalancerParam) GetForce() bool {
	return p.Force
}
func (p *DeleteLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// BootLoadBalancerParam is input parameters for the sacloud API
type BootLoadBalancerParam 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"`
}

// NewBootLoadBalancerParam return new BootLoadBalancerParam
func NewBootLoadBalancerParam() *BootLoadBalancerParam {
	return &BootLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *BootLoadBalancerParam) 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 *BootLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ShutdownLoadBalancerParam is input parameters for the sacloud API
type ShutdownLoadBalancerParam 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"`
}

// NewShutdownLoadBalancerParam return new ShutdownLoadBalancerParam
func NewShutdownLoadBalancerParam() *ShutdownLoadBalancerParam {
	return &ShutdownLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ShutdownLoadBalancerParam) 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 *ShutdownLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ShutdownForceLoadBalancerParam is input parameters for the sacloud API
type ShutdownForceLoadBalancerParam 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"`
}

// NewShutdownForceLoadBalancerParam return new ShutdownForceLoadBalancerParam
func NewShutdownForceLoadBalancerParam() *ShutdownForceLoadBalancerParam {
	return &ShutdownForceLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ShutdownForceLoadBalancerParam) 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 *ShutdownForceLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// ResetLoadBalancerParam is input parameters for the sacloud API
type ResetLoadBalancerParam 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"`
}

// NewResetLoadBalancerParam return new ResetLoadBalancerParam
func NewResetLoadBalancerParam() *ResetLoadBalancerParam {
	return &ResetLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ResetLoadBalancerParam) 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 *ResetLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// WaitForBootLoadBalancerParam is input parameters for the sacloud API
type WaitForBootLoadBalancerParam 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"`
}

// NewWaitForBootLoadBalancerParam return new WaitForBootLoadBalancerParam
func NewWaitForBootLoadBalancerParam() *WaitForBootLoadBalancerParam {
	return &WaitForBootLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *WaitForBootLoadBalancerParam) 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 *WaitForBootLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

// WaitForDownLoadBalancerParam is input parameters for the sacloud API
type WaitForDownLoadBalancerParam 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"`
}

// NewWaitForDownLoadBalancerParam return new WaitForDownLoadBalancerParam
func NewWaitForDownLoadBalancerParam() *WaitForDownLoadBalancerParam {
	return &WaitForDownLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *WaitForDownLoadBalancerParam) 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 *WaitForDownLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateSakuraID
		errs := validator("--id", p.Id)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

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

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

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

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

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

// VipInfoLoadBalancerParam is input parameters for the sacloud API
type VipInfoLoadBalancerParam 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"`
}

// NewVipInfoLoadBalancerParam return new VipInfoLoadBalancerParam
func NewVipInfoLoadBalancerParam() *VipInfoLoadBalancerParam {
	return &VipInfoLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *VipInfoLoadBalancerParam) 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 *VipInfoLoadBalancerParam) 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 *VipInfoLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// VipAddLoadBalancerParam is input parameters for the sacloud API
type VipAddLoadBalancerParam struct {
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	DelayLoop         int        `json:"delay-loop"`
	SorryServer       string     `json:"sorry-server"`
	Description       string     `json:"description"`
	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"`
}

// NewVipAddLoadBalancerParam return new VipAddLoadBalancerParam
func NewVipAddLoadBalancerParam() *VipAddLoadBalancerParam {
	return &VipAddLoadBalancerParam{

		DelayLoop: 10,
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *VipAddLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.DelayLoop) {
		p.DelayLoop = 0
	}
	if isEmpty(p.SorryServer) {
		p.SorryServer = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	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 *VipAddLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-add"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-add"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-add"].Params["delay-loop"].ValidateFunc
		errs := validator("--delay-loop", p.DelayLoop)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-add"].Params["sorry-server"].ValidateFunc
		errs := validator("--sorry-server", p.SorryServer)
		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 *VipAddLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

func (p *VipAddLoadBalancerParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["vip-add"]
}

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

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

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

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

func (p *VipAddLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *VipAddLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *VipAddLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *VipAddLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *VipAddLoadBalancerParam) SetDelayLoop(v int) {
	p.DelayLoop = v
}

func (p *VipAddLoadBalancerParam) GetDelayLoop() int {
	return p.DelayLoop
}
func (p *VipAddLoadBalancerParam) SetSorryServer(v string) {
	p.SorryServer = v
}

func (p *VipAddLoadBalancerParam) GetSorryServer() string {
	return p.SorryServer
}
func (p *VipAddLoadBalancerParam) SetDescription(v string) {
	p.Description = v
}

func (p *VipAddLoadBalancerParam) GetDescription() string {
	return p.Description
}
func (p *VipAddLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// VipUpdateLoadBalancerParam is input parameters for the sacloud API
type VipUpdateLoadBalancerParam struct {
	Index             int        `json:"index"`
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	DelayLoop         int        `json:"delay-loop"`
	SorryServer       string     `json:"sorry-server"`
	Description       string     `json:"description"`
	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"`
}

// NewVipUpdateLoadBalancerParam return new VipUpdateLoadBalancerParam
func NewVipUpdateLoadBalancerParam() *VipUpdateLoadBalancerParam {
	return &VipUpdateLoadBalancerParam{

		DelayLoop: 10,
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *VipUpdateLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.DelayLoop) {
		p.DelayLoop = 0
	}
	if isEmpty(p.SorryServer) {
		p.SorryServer = ""
	}
	if isEmpty(p.Description) {
		p.Description = ""
	}
	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 *VipUpdateLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		errs := validator("--index", p.Index)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-update"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-update"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-update"].Params["delay-loop"].ValidateFunc
		errs := validator("--delay-loop", p.DelayLoop)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["vip-update"].Params["sorry-server"].ValidateFunc
		errs := validator("--sorry-server", p.SorryServer)
		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 *VipUpdateLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

func (p *VipUpdateLoadBalancerParam) GetIndex() int {
	return p.Index
}
func (p *VipUpdateLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *VipUpdateLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *VipUpdateLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *VipUpdateLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *VipUpdateLoadBalancerParam) SetDelayLoop(v int) {
	p.DelayLoop = v
}

func (p *VipUpdateLoadBalancerParam) GetDelayLoop() int {
	return p.DelayLoop
}
func (p *VipUpdateLoadBalancerParam) SetSorryServer(v string) {
	p.SorryServer = v
}

func (p *VipUpdateLoadBalancerParam) GetSorryServer() string {
	return p.SorryServer
}
func (p *VipUpdateLoadBalancerParam) SetDescription(v string) {
	p.Description = v
}

func (p *VipUpdateLoadBalancerParam) GetDescription() string {
	return p.Description
}
func (p *VipUpdateLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// VipDeleteLoadBalancerParam is input parameters for the sacloud API
type VipDeleteLoadBalancerParam struct {
	Index             int        `json:"index"`
	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"`
}

// NewVipDeleteLoadBalancerParam return new VipDeleteLoadBalancerParam
func NewVipDeleteLoadBalancerParam() *VipDeleteLoadBalancerParam {
	return &VipDeleteLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *VipDeleteLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.Index) {
		p.Index = 0
	}
	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 *VipDeleteLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := validateRequired
		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...)
		}
	}

	return errors
}

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

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

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

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

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

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

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

func (p *VipDeleteLoadBalancerParam) GetIndex() int {
	return p.Index
}
func (p *VipDeleteLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// ServerInfoLoadBalancerParam is input parameters for the sacloud API
type ServerInfoLoadBalancerParam struct {
	VipIndex          int        `json:"vip-index"`
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	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"`
}

// NewServerInfoLoadBalancerParam return new ServerInfoLoadBalancerParam
func NewServerInfoLoadBalancerParam() *ServerInfoLoadBalancerParam {
	return &ServerInfoLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ServerInfoLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.VipIndex) {
		p.VipIndex = 0
	}
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	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 *ServerInfoLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		errs := validateConflicts("--vip-index", p.VipIndex, map[string]interface{}{

			"--port": p.Port,
			"--vip":  p.Vip,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-info"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--vip", p.Vip, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-info"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--port", p.Port, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		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 *ServerInfoLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

func (p *ServerInfoLoadBalancerParam) SetVipIndex(v int) {
	p.VipIndex = v
}

func (p *ServerInfoLoadBalancerParam) GetVipIndex() int {
	return p.VipIndex
}
func (p *ServerInfoLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *ServerInfoLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *ServerInfoLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *ServerInfoLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *ServerInfoLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

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

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

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

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

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

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

// ServerAddLoadBalancerParam is input parameters for the sacloud API
type ServerAddLoadBalancerParam struct {
	VipIndex          int        `json:"vip-index"`
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	Ipaddress         string     `json:"ipaddress"`
	Protocol          string     `json:"protocol"`
	Path              string     `json:"path"`
	ResponseCode      int        `json:"response-code"`
	Disabled          bool       `json:"disabled"`
	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"`
}

// NewServerAddLoadBalancerParam return new ServerAddLoadBalancerParam
func NewServerAddLoadBalancerParam() *ServerAddLoadBalancerParam {
	return &ServerAddLoadBalancerParam{

		Protocol: "ping",
	}
}

// FillValueToSkeleton fill values to empty fields
func (p *ServerAddLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.VipIndex) {
		p.VipIndex = 0
	}
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.Ipaddress) {
		p.Ipaddress = ""
	}
	if isEmpty(p.Protocol) {
		p.Protocol = ""
	}
	if isEmpty(p.Path) {
		p.Path = ""
	}
	if isEmpty(p.ResponseCode) {
		p.ResponseCode = 0
	}
	if isEmpty(p.Disabled) {
		p.Disabled = false
	}
	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 *ServerAddLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		errs := validateConflicts("--vip-index", p.VipIndex, map[string]interface{}{

			"--port": p.Port,
			"--vip":  p.Vip,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-add"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--vip", p.Vip, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-add"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--port", p.Port, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress", p.Ipaddress)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-add"].Params["ipaddress"].ValidateFunc
		errs := validator("--ipaddress", p.Ipaddress)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--protocol", p.Protocol)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-add"].Params["protocol"].ValidateFunc
		errs := validator("--protocol", p.Protocol)
		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 *ServerAddLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

func (p *ServerAddLoadBalancerParam) GetCommandDef() *schema.Command {
	return p.GetResourceDef().Commands["server-add"]
}

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

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

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

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

func (p *ServerAddLoadBalancerParam) SetVipIndex(v int) {
	p.VipIndex = v
}

func (p *ServerAddLoadBalancerParam) GetVipIndex() int {
	return p.VipIndex
}
func (p *ServerAddLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *ServerAddLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *ServerAddLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *ServerAddLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *ServerAddLoadBalancerParam) SetIpaddress(v string) {
	p.Ipaddress = v
}

func (p *ServerAddLoadBalancerParam) GetIpaddress() string {
	return p.Ipaddress
}
func (p *ServerAddLoadBalancerParam) SetProtocol(v string) {
	p.Protocol = v
}

func (p *ServerAddLoadBalancerParam) GetProtocol() string {
	return p.Protocol
}
func (p *ServerAddLoadBalancerParam) SetPath(v string) {
	p.Path = v
}

func (p *ServerAddLoadBalancerParam) GetPath() string {
	return p.Path
}
func (p *ServerAddLoadBalancerParam) SetResponseCode(v int) {
	p.ResponseCode = v
}

func (p *ServerAddLoadBalancerParam) GetResponseCode() int {
	return p.ResponseCode
}
func (p *ServerAddLoadBalancerParam) SetDisabled(v bool) {
	p.Disabled = v
}

func (p *ServerAddLoadBalancerParam) GetDisabled() bool {
	return p.Disabled
}
func (p *ServerAddLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// ServerUpdateLoadBalancerParam is input parameters for the sacloud API
type ServerUpdateLoadBalancerParam struct {
	VipIndex          int        `json:"vip-index"`
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	Ipaddress         string     `json:"ipaddress"`
	Protocol          string     `json:"protocol"`
	Path              string     `json:"path"`
	ResponseCode      int        `json:"response-code"`
	Disabled          bool       `json:"disabled"`
	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"`
}

// NewServerUpdateLoadBalancerParam return new ServerUpdateLoadBalancerParam
func NewServerUpdateLoadBalancerParam() *ServerUpdateLoadBalancerParam {
	return &ServerUpdateLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ServerUpdateLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.VipIndex) {
		p.VipIndex = 0
	}
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.Ipaddress) {
		p.Ipaddress = ""
	}
	if isEmpty(p.Protocol) {
		p.Protocol = ""
	}
	if isEmpty(p.Path) {
		p.Path = ""
	}
	if isEmpty(p.ResponseCode) {
		p.ResponseCode = 0
	}
	if isEmpty(p.Disabled) {
		p.Disabled = false
	}
	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 *ServerUpdateLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		errs := validateConflicts("--vip-index", p.VipIndex, map[string]interface{}{

			"--port": p.Port,
			"--vip":  p.Vip,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-update"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--vip", p.Vip, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-update"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--port", p.Port, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress", p.Ipaddress)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-update"].Params["ipaddress"].ValidateFunc
		errs := validator("--ipaddress", p.Ipaddress)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-update"].Params["protocol"].ValidateFunc
		errs := validator("--protocol", p.Protocol)
		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 *ServerUpdateLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

func (p *ServerUpdateLoadBalancerParam) SetVipIndex(v int) {
	p.VipIndex = v
}

func (p *ServerUpdateLoadBalancerParam) GetVipIndex() int {
	return p.VipIndex
}
func (p *ServerUpdateLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *ServerUpdateLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *ServerUpdateLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *ServerUpdateLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *ServerUpdateLoadBalancerParam) SetIpaddress(v string) {
	p.Ipaddress = v
}

func (p *ServerUpdateLoadBalancerParam) GetIpaddress() string {
	return p.Ipaddress
}
func (p *ServerUpdateLoadBalancerParam) SetProtocol(v string) {
	p.Protocol = v
}

func (p *ServerUpdateLoadBalancerParam) GetProtocol() string {
	return p.Protocol
}
func (p *ServerUpdateLoadBalancerParam) SetPath(v string) {
	p.Path = v
}

func (p *ServerUpdateLoadBalancerParam) GetPath() string {
	return p.Path
}
func (p *ServerUpdateLoadBalancerParam) SetResponseCode(v int) {
	p.ResponseCode = v
}

func (p *ServerUpdateLoadBalancerParam) GetResponseCode() int {
	return p.ResponseCode
}
func (p *ServerUpdateLoadBalancerParam) SetDisabled(v bool) {
	p.Disabled = v
}

func (p *ServerUpdateLoadBalancerParam) GetDisabled() bool {
	return p.Disabled
}
func (p *ServerUpdateLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// ServerDeleteLoadBalancerParam is input parameters for the sacloud API
type ServerDeleteLoadBalancerParam struct {
	VipIndex          int        `json:"vip-index"`
	Vip               string     `json:"vip"`
	Port              int        `json:"port"`
	Ipaddress         string     `json:"ipaddress"`
	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"`
}

// NewServerDeleteLoadBalancerParam return new ServerDeleteLoadBalancerParam
func NewServerDeleteLoadBalancerParam() *ServerDeleteLoadBalancerParam {
	return &ServerDeleteLoadBalancerParam{}
}

// FillValueToSkeleton fill values to empty fields
func (p *ServerDeleteLoadBalancerParam) FillValueToSkeleton() {
	if isEmpty(p.VipIndex) {
		p.VipIndex = 0
	}
	if isEmpty(p.Vip) {
		p.Vip = ""
	}
	if isEmpty(p.Port) {
		p.Port = 0
	}
	if isEmpty(p.Ipaddress) {
		p.Ipaddress = ""
	}
	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 *ServerDeleteLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		errs := validateConflicts("--vip-index", p.VipIndex, map[string]interface{}{

			"--port": p.Port,
			"--vip":  p.Vip,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-delete"].Params["vip"].ValidateFunc
		errs := validator("--vip", p.Vip)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--vip", p.Vip, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-delete"].Params["port"].ValidateFunc
		errs := validator("--port", p.Port)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		errs := validateConflicts("--port", p.Port, map[string]interface{}{

			"--vip-index": p.VipIndex,
		})
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := validateRequired
		errs := validator("--ipaddress", p.Ipaddress)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["server-delete"].Params["ipaddress"].ValidateFunc
		errs := validator("--ipaddress", p.Ipaddress)
		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 *ServerDeleteLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

func (p *ServerDeleteLoadBalancerParam) SetVipIndex(v int) {
	p.VipIndex = v
}

func (p *ServerDeleteLoadBalancerParam) GetVipIndex() int {
	return p.VipIndex
}
func (p *ServerDeleteLoadBalancerParam) SetVip(v string) {
	p.Vip = v
}

func (p *ServerDeleteLoadBalancerParam) GetVip() string {
	return p.Vip
}
func (p *ServerDeleteLoadBalancerParam) SetPort(v int) {
	p.Port = v
}

func (p *ServerDeleteLoadBalancerParam) GetPort() int {
	return p.Port
}
func (p *ServerDeleteLoadBalancerParam) SetIpaddress(v string) {
	p.Ipaddress = v
}

func (p *ServerDeleteLoadBalancerParam) GetIpaddress() string {
	return p.Ipaddress
}
func (p *ServerDeleteLoadBalancerParam) SetSelector(v []string) {
	p.Selector = v
}

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

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

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

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

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

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

// MonitorLoadBalancerParam is input parameters for the sacloud API
type MonitorLoadBalancerParam 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"`
}

// NewMonitorLoadBalancerParam return new MonitorLoadBalancerParam
func NewMonitorLoadBalancerParam() *MonitorLoadBalancerParam {
	return &MonitorLoadBalancerParam{

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

// FillValueToSkeleton fill values to empty fields
func (p *MonitorLoadBalancerParam) 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 *MonitorLoadBalancerParam) Validate() []error {
	errors := []error{}
	{
		validator := define.Resources["LoadBalancer"].Commands["monitor"].Params["start"].ValidateFunc
		errs := validator("--start", p.Start)
		if errs != nil {
			errors = append(errors, errs...)
		}
	}
	{
		validator := define.Resources["LoadBalancer"].Commands["monitor"].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 *MonitorLoadBalancerParam) GetResourceDef() *schema.Resource {
	return define.Resources["LoadBalancer"]
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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