operations_client.go

// Code generated by go-swagger; DO NOT EDIT.

// Copyright 2017 The go-ovh 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.

package operations

// This file was generated by the swagger tool.
// Editing this file might prove futile when you re-run the swagger generate command

import (
	"github.com/go-openapi/runtime"

	strfmt "github.com/go-openapi/strfmt"
)

// New creates a new operations API client.
func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client {
	return &Client{transport: transport, formats: formats}
}

/*
Client for operations API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
}

/*
DeleteVpsServiceNameBackupftpAccessIPBlock revokes this ACL

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameBackupftpAccessIPBlock(params *DeleteVpsServiceNameBackupftpAccessIPBlockParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameBackupftpAccessIPBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameBackupftpAccessIPBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameBackupftpAccessIPBlock",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/backupftp/access/{ipBlock}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameBackupftpAccessIPBlockReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameBackupftpAccessIPBlockOK), nil

}

/*
DeleteVpsServiceNameIpsIPAddress releases a given Ip additional Ip

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameIpsIPAddress(params *DeleteVpsServiceNameIpsIPAddressParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameIpsIPAddressOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameIpsIPAddressParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameIpsIPAddress",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/ips/{ipAddress}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameIpsIPAddressReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameIpsIPAddressOK), nil

}

/*
DeleteVpsServiceNameOptionOption releases a given option

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameOptionOption(params *DeleteVpsServiceNameOptionOptionParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameOptionOptionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameOptionOptionParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameOptionOption",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/option/{option}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameOptionOptionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameOptionOptionOK), nil

}

/*
DeleteVpsServiceNameSecondaryDNSDomainsDomain removes this domain

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameSecondaryDNSDomainsDomain(params *DeleteVpsServiceNameSecondaryDNSDomainsDomainParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameSecondaryDNSDomainsDomainOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameSecondaryDNSDomainsDomainParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameSecondaryDNSDomainsDomain",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains/{domain}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameSecondaryDNSDomainsDomainReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameSecondaryDNSDomainsDomainOK), nil

}

/*
DeleteVpsServiceNameSnapshot creates a vps task that will delete the snapshot

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameSnapshot(params *DeleteVpsServiceNameSnapshotParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameSnapshotOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameSnapshotParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameSnapshot",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/snapshot",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameSnapshotReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameSnapshotOK), nil

}

/*
DeleteVpsServiceNameVeeamRestoredBackup creates a v p s task that will unmount the backup

PRODUCTION - authentication required
*/
func (a *Client) DeleteVpsServiceNameVeeamRestoredBackup(params *DeleteVpsServiceNameVeeamRestoredBackupParams, authInfo runtime.ClientAuthInfoWriter) (*DeleteVpsServiceNameVeeamRestoredBackupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteVpsServiceNameVeeamRestoredBackupParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "DeleteVpsServiceNameVeeamRestoredBackup",
		Method:             "DELETE",
		PathPattern:        "/vps/{serviceName}/veeam/restoredBackup",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteVpsServiceNameVeeamRestoredBackupReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteVpsServiceNameVeeamRestoredBackupOK), nil

}

/*
GetVps lists available services

PRODUCTION - authentication required
*/
func (a *Client) GetVps(params *GetVpsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVps",
		Method:             "GET",
		PathPattern:        "/vps",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsOK), nil

}

/*
GetVpsDatacenter lists all the datacenters for a specific country

PRODUCTION
*/
func (a *Client) GetVpsDatacenter(params *GetVpsDatacenterParams) (*GetVpsDatacenterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsDatacenterParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsDatacenter",
		Method:             "GET",
		PathPattern:        "/vps/datacenter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsDatacenterReader{formats: a.formats},
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsDatacenterOK), nil

}

/*
GetVpsServiceName gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceName(params *GetVpsServiceNameParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceName",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameOK), nil

}

/*
GetVpsServiceNameActiveOptions returns all active options for the virtual server

DEPRECATED (see '/vps/{serviceName}/option') - authentication required
*/
func (a *Client) GetVpsServiceNameActiveOptions(params *GetVpsServiceNameActiveOptionsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameActiveOptionsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameActiveOptionsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameActiveOptions",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/activeOptions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameActiveOptionsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameActiveOptionsOK), nil

}

/*
GetVpsServiceNameAutomatedBackup gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameAutomatedBackup(params *GetVpsServiceNameAutomatedBackupParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameAutomatedBackupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameAutomatedBackupParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameAutomatedBackup",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/automatedBackup",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameAutomatedBackupReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameAutomatedBackupOK), nil

}

/*
GetVpsServiceNameAutomatedBackupAttachedBackup backups attached to your v p s

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameAutomatedBackupAttachedBackup(params *GetVpsServiceNameAutomatedBackupAttachedBackupParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameAutomatedBackupAttachedBackupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameAutomatedBackupAttachedBackupParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameAutomatedBackupAttachedBackup",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/automatedBackup/attachedBackup",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameAutomatedBackupAttachedBackupReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameAutomatedBackupAttachedBackupOK), nil

}

/*
GetVpsServiceNameAutomatedBackupRestorePoints gets available restore points

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameAutomatedBackupRestorePoints(params *GetVpsServiceNameAutomatedBackupRestorePointsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameAutomatedBackupRestorePointsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameAutomatedBackupRestorePointsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameAutomatedBackupRestorePoints",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/automatedBackup/restorePoints",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameAutomatedBackupRestorePointsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameAutomatedBackupRestorePointsOK), nil

}

/*
GetVpsServiceNameAvailableUpgrade returns all models the virtual server can be upgraded to

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameAvailableUpgrade(params *GetVpsServiceNameAvailableUpgradeParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameAvailableUpgradeOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameAvailableUpgradeParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameAvailableUpgrade",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/availableUpgrade",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameAvailableUpgradeReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameAvailableUpgradeOK), nil

}

/*
GetVpsServiceNameBackupftp gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameBackupftp(params *GetVpsServiceNameBackupftpParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameBackupftpOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameBackupftpParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameBackupftp",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/backupftp",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameBackupftpReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameBackupftpOK), nil

}

/*
GetVpsServiceNameBackupftpAccess lists of IP blocks and protocols to allow on these blocks authorized on your backup f t p

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameBackupftpAccess(params *GetVpsServiceNameBackupftpAccessParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameBackupftpAccessOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameBackupftpAccessParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameBackupftpAccess",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/backupftp/access",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameBackupftpAccessReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameBackupftpAccessOK), nil

}

/*
GetVpsServiceNameBackupftpAccessIPBlock gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameBackupftpAccessIPBlock(params *GetVpsServiceNameBackupftpAccessIPBlockParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameBackupftpAccessIPBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameBackupftpAccessIPBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameBackupftpAccessIPBlock",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/backupftp/access/{ipBlock}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameBackupftpAccessIPBlockReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameBackupftpAccessIPBlockOK), nil

}

/*
GetVpsServiceNameBackupftpAuthorizableBlocks gets all IP blocks that can be used in the ACL

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameBackupftpAuthorizableBlocks(params *GetVpsServiceNameBackupftpAuthorizableBlocksParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameBackupftpAuthorizableBlocksOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameBackupftpAuthorizableBlocksParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameBackupftpAuthorizableBlocks",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/backupftp/authorizableBlocks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameBackupftpAuthorizableBlocksReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameBackupftpAuthorizableBlocksOK), nil

}

/*
GetVpsServiceNameDatacenter gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDatacenter(params *GetVpsServiceNameDatacenterParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDatacenterOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDatacenterParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDatacenter",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/datacenter",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDatacenterReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDatacenterOK), nil

}

/*
GetVpsServiceNameDisks disks associated to this virtual server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDisks(params *GetVpsServiceNameDisksParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDisksOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDisksParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDisks",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/disks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDisksReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDisksOK), nil

}

/*
GetVpsServiceNameDisksID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDisksID(params *GetVpsServiceNameDisksIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDisksIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDisksIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDisksID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/disks/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDisksIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDisksIDOK), nil

}

/*
GetVpsServiceNameDisksIDMonitoring returns many statistics about the disk for a given period

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDisksIDMonitoring(params *GetVpsServiceNameDisksIDMonitoringParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDisksIDMonitoringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDisksIDMonitoringParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDisksIDMonitoring",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/disks/{id}/monitoring",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDisksIDMonitoringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDisksIDMonitoringOK), nil

}

/*
GetVpsServiceNameDisksIDUse returns many statistics about the disk at that time

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDisksIDUse(params *GetVpsServiceNameDisksIDUseParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDisksIDUseOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDisksIDUseParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDisksIDUse",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/disks/{id}/use",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDisksIDUseReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDisksIDUseOK), nil

}

/*
GetVpsServiceNameDistribution gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDistribution(params *GetVpsServiceNameDistributionParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDistributionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDistributionParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDistribution",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/distribution",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDistributionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDistributionOK), nil

}

/*
GetVpsServiceNameDistributionSoftware lists available softwares for this template Id

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDistributionSoftware(params *GetVpsServiceNameDistributionSoftwareParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDistributionSoftwareOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDistributionSoftwareParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDistributionSoftware",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/distribution/software",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDistributionSoftwareReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDistributionSoftwareOK), nil

}

/*
GetVpsServiceNameDistributionSoftwareSoftwareID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameDistributionSoftwareSoftwareID(params *GetVpsServiceNameDistributionSoftwareSoftwareIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameDistributionSoftwareSoftwareIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameDistributionSoftwareSoftwareIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameDistributionSoftwareSoftwareID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/distribution/software/{softwareId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameDistributionSoftwareSoftwareIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameDistributionSoftwareSoftwareIDOK), nil

}

/*
GetVpsServiceNameIPCountryAvailable gets the countries you can select for your ips geolocation

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameIPCountryAvailable(params *GetVpsServiceNameIPCountryAvailableParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameIPCountryAvailableOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameIPCountryAvailableParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameIPCountryAvailable",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/ipCountryAvailable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameIPCountryAvailableReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameIPCountryAvailableOK), nil

}

/*
GetVpsServiceNameIps ips associated to this virtual server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameIps(params *GetVpsServiceNameIpsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameIpsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameIpsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameIps",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/ips",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameIpsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameIpsOK), nil

}

/*
GetVpsServiceNameIpsIPAddress gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameIpsIPAddress(params *GetVpsServiceNameIpsIPAddressParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameIpsIPAddressOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameIpsIPAddressParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameIpsIPAddress",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/ips/{ipAddress}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameIpsIPAddressReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameIpsIPAddressOK), nil

}

/*
GetVpsServiceNameModels returns all models for the range of the virtual server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameModels(params *GetVpsServiceNameModelsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameModelsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameModelsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameModels",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/models",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameModelsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameModelsOK), nil

}

/*
GetVpsServiceNameMonitoring returns many statistics about the virtual machine for a given period

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameMonitoring(params *GetVpsServiceNameMonitoringParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameMonitoringOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameMonitoringParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameMonitoring",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/monitoring",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameMonitoringReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameMonitoringOK), nil

}

/*
GetVpsServiceNameOption lists of v p s options

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameOption(params *GetVpsServiceNameOptionParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameOptionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameOptionParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameOption",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/option",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameOptionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameOptionOK), nil

}

/*
GetVpsServiceNameOptionOption gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameOptionOption(params *GetVpsServiceNameOptionOptionParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameOptionOptionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameOptionOptionParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameOptionOption",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/option/{option}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameOptionOptionReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameOptionOptionOK), nil

}

/*
GetVpsServiceNameSecondaryDNSDomains lists of secondary dns domain name

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameSecondaryDNSDomains(params *GetVpsServiceNameSecondaryDNSDomainsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameSecondaryDNSDomainsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameSecondaryDNSDomainsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameSecondaryDNSDomains",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameSecondaryDNSDomainsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameSecondaryDNSDomainsOK), nil

}

/*
GetVpsServiceNameSecondaryDNSDomainsDomain gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameSecondaryDNSDomainsDomain(params *GetVpsServiceNameSecondaryDNSDomainsDomainParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameSecondaryDNSDomainsDomainOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameSecondaryDNSDomainsDomainParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameSecondaryDNSDomainsDomain",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains/{domain}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameSecondaryDNSDomainsDomainReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameSecondaryDNSDomainsDomainOK), nil

}

/*
GetVpsServiceNameSecondaryDNSDomainsDomainDNSServer domains name server informations

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameSecondaryDNSDomainsDomainDNSServer(params *GetVpsServiceNameSecondaryDNSDomainsDomainDNSServerParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameSecondaryDNSDomainsDomainDNSServerOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameSecondaryDNSDomainsDomainDNSServerParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameSecondaryDNSDomainsDomainDNSServer",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains/{domain}/dnsServer",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameSecondaryDNSDomainsDomainDNSServerReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameSecondaryDNSDomainsDomainDNSServerOK), nil

}

/*
GetVpsServiceNameSecondaryDNSNameServerAvailable secondaries name server available for your server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameSecondaryDNSNameServerAvailable(params *GetVpsServiceNameSecondaryDNSNameServerAvailableParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameSecondaryDNSNameServerAvailableOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameSecondaryDNSNameServerAvailableParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameSecondaryDNSNameServerAvailable",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/secondaryDnsNameServerAvailable",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameSecondaryDNSNameServerAvailableReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameSecondaryDNSNameServerAvailableOK), nil

}

/*
GetVpsServiceNameServiceInfos gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameServiceInfos(params *GetVpsServiceNameServiceInfosParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameServiceInfosOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameServiceInfosParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameServiceInfos",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/serviceInfos",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameServiceInfosReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameServiceInfosOK), nil

}

/*
GetVpsServiceNameSnapshot gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameSnapshot(params *GetVpsServiceNameSnapshotParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameSnapshotOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameSnapshotParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameSnapshot",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/snapshot",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameSnapshotReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameSnapshotOK), nil

}

/*
GetVpsServiceNameStatus gives the status of the services of the main IP

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameStatus(params *GetVpsServiceNameStatusParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameStatusOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameStatusParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameStatus",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/status",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameStatusReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameStatusOK), nil

}

/*
GetVpsServiceNameTasks tasks associated to this virtual server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTasks(params *GetVpsServiceNameTasksParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTasksOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTasksParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTasks",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/tasks",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTasksReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTasksOK), nil

}

/*
GetVpsServiceNameTasksID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTasksID(params *GetVpsServiceNameTasksIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTasksIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTasksIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTasksID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/tasks/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTasksIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTasksIDOK), nil

}

/*
GetVpsServiceNameTemplates templates available for this virtual server

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTemplates(params *GetVpsServiceNameTemplatesParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTemplatesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTemplatesParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTemplates",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/templates",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTemplatesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTemplatesOK), nil

}

/*
GetVpsServiceNameTemplatesID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTemplatesID(params *GetVpsServiceNameTemplatesIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTemplatesIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTemplatesIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTemplatesID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/templates/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTemplatesIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTemplatesIDOK), nil

}

/*
GetVpsServiceNameTemplatesIDSoftware lists available softwares for this template Id

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTemplatesIDSoftware(params *GetVpsServiceNameTemplatesIDSoftwareParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTemplatesIDSoftwareOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTemplatesIDSoftwareParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTemplatesIDSoftware",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/templates/{id}/software",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTemplatesIDSoftwareReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTemplatesIDSoftwareOK), nil

}

/*
GetVpsServiceNameTemplatesIDSoftwareSoftwareID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameTemplatesIDSoftwareSoftwareID(params *GetVpsServiceNameTemplatesIDSoftwareSoftwareIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameTemplatesIDSoftwareSoftwareIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameTemplatesIDSoftwareSoftwareIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameTemplatesIDSoftwareSoftwareID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/templates/{id}/software/{softwareId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameTemplatesIDSoftwareSoftwareIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameTemplatesIDSoftwareSoftwareIDOK), nil

}

/*
GetVpsServiceNameUse returns many statistics about the virtual machine at that time

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameUse(params *GetVpsServiceNameUseParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameUseOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameUseParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameUse",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/use",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameUseReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameUseOK), nil

}

/*
GetVpsServiceNameVeeam gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameVeeam(params *GetVpsServiceNameVeeamParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameVeeamOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameVeeamParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameVeeam",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/veeam",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameVeeamReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameVeeamOK), nil

}

/*
GetVpsServiceNameVeeamRestorePoints veeams restore points for the v p s

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameVeeamRestorePoints(params *GetVpsServiceNameVeeamRestorePointsParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameVeeamRestorePointsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameVeeamRestorePointsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameVeeamRestorePoints",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/veeam/restorePoints",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameVeeamRestorePointsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameVeeamRestorePointsOK), nil

}

/*
GetVpsServiceNameVeeamRestorePointsID gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameVeeamRestorePointsID(params *GetVpsServiceNameVeeamRestorePointsIDParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameVeeamRestorePointsIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameVeeamRestorePointsIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameVeeamRestorePointsID",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/veeam/restorePoints/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameVeeamRestorePointsIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameVeeamRestorePointsIDOK), nil

}

/*
GetVpsServiceNameVeeamRestoredBackup gets this object properties

PRODUCTION - authentication required
*/
func (a *Client) GetVpsServiceNameVeeamRestoredBackup(params *GetVpsServiceNameVeeamRestoredBackupParams, authInfo runtime.ClientAuthInfoWriter) (*GetVpsServiceNameVeeamRestoredBackupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetVpsServiceNameVeeamRestoredBackupParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "GetVpsServiceNameVeeamRestoredBackup",
		Method:             "GET",
		PathPattern:        "/vps/{serviceName}/veeam/restoredBackup",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetVpsServiceNameVeeamRestoredBackupReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetVpsServiceNameVeeamRestoredBackupOK), nil

}

/*
PostVpsServiceNameAutomatedBackupDetachBackup creates a v p s task that will umount a restored backup on your v p s

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameAutomatedBackupDetachBackup(params *PostVpsServiceNameAutomatedBackupDetachBackupParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameAutomatedBackupDetachBackupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameAutomatedBackupDetachBackupParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameAutomatedBackupDetachBackup",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/automatedBackup/detachBackup",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameAutomatedBackupDetachBackupReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameAutomatedBackupDetachBackupOK), nil

}

/*
PostVpsServiceNameAutomatedBackupRestore creates a v p s task that will restore the given restore point

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameAutomatedBackupRestore(params *PostVpsServiceNameAutomatedBackupRestoreParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameAutomatedBackupRestoreOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameAutomatedBackupRestoreParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameAutomatedBackupRestore",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/automatedBackup/restore",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameAutomatedBackupRestoreReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameAutomatedBackupRestoreOK), nil

}

/*
PostVpsServiceNameBackupftpAccess creates a new backup f t p ACL

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameBackupftpAccess(params *PostVpsServiceNameBackupftpAccessParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameBackupftpAccessOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameBackupftpAccessParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameBackupftpAccess",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/backupftp/access",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameBackupftpAccessReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameBackupftpAccessOK), nil

}

/*
PostVpsServiceNameBackupftpPassword changes your backup f t p password

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameBackupftpPassword(params *PostVpsServiceNameBackupftpPasswordParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameBackupftpPasswordOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameBackupftpPasswordParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameBackupftpPassword",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/backupftp/password",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameBackupftpPasswordReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameBackupftpPasswordOK), nil

}

/*
PostVpsServiceNameChangeContact launches a contact change procedure

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameChangeContact(params *PostVpsServiceNameChangeContactParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameChangeContactOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameChangeContactParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameChangeContact",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/changeContact",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameChangeContactReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameChangeContactOK), nil

}

/*
PostVpsServiceNameConfirmTermination confirms termination of your service

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameConfirmTermination(params *PostVpsServiceNameConfirmTerminationParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameConfirmTerminationOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameConfirmTerminationParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameConfirmTermination",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/confirmTermination",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameConfirmTerminationReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameConfirmTerminationOK), nil

}

/*
PostVpsServiceNameCreateSnapshot creates a snapshot of the virtual server if the snapshot option is enabled and if there is no existing snapshot

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameCreateSnapshot(params *PostVpsServiceNameCreateSnapshotParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameCreateSnapshotOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameCreateSnapshotParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameCreateSnapshot",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/createSnapshot",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameCreateSnapshotReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameCreateSnapshotOK), nil

}

/*
PostVpsServiceNameGetConsoleURL returns the v p s console URL

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameGetConsoleURL(params *PostVpsServiceNameGetConsoleURLParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameGetConsoleURLOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameGetConsoleURLParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameGetConsoleURL",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/getConsoleUrl",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameGetConsoleURLReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameGetConsoleURLOK), nil

}

/*
PostVpsServiceNameOpenConsoleAccess returns the necessary informations to open a v n c connection to your v p s

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameOpenConsoleAccess(params *PostVpsServiceNameOpenConsoleAccessParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameOpenConsoleAccessOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameOpenConsoleAccessParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameOpenConsoleAccess",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/openConsoleAccess",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameOpenConsoleAccessReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameOpenConsoleAccessOK), nil

}

/*
PostVpsServiceNameReboot requests a reboot of the machine

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameReboot(params *PostVpsServiceNameRebootParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameRebootOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameRebootParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameReboot",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/reboot",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameRebootReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameRebootOK), nil

}

/*
PostVpsServiceNameReinstall reinstalls the virtual server

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameReinstall(params *PostVpsServiceNameReinstallParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameReinstallOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameReinstallParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameReinstall",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/reinstall",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameReinstallReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameReinstallOK), nil

}

/*
PostVpsServiceNameSecondaryDNSDomains adds a domain on secondary dns

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameSecondaryDNSDomains(params *PostVpsServiceNameSecondaryDNSDomainsParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameSecondaryDNSDomainsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameSecondaryDNSDomainsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameSecondaryDNSDomains",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameSecondaryDNSDomainsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameSecondaryDNSDomainsOK), nil

}

/*
PostVpsServiceNameSetPassword starts the process in order to set the root password of the virtual machine be careful in case of cloud model a reboot is mandatory

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameSetPassword(params *PostVpsServiceNameSetPasswordParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameSetPasswordOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameSetPasswordParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameSetPassword",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/setPassword",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameSetPasswordReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameSetPasswordOK), nil

}

/*
PostVpsServiceNameSnapshotRevert reverts the virtual server to this snapshot

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameSnapshotRevert(params *PostVpsServiceNameSnapshotRevertParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameSnapshotRevertOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameSnapshotRevertParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameSnapshotRevert",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/snapshot/revert",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameSnapshotRevertReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameSnapshotRevertOK), nil

}

/*
PostVpsServiceNameStart requests the machine to start

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameStart(params *PostVpsServiceNameStartParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameStartOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameStartParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameStart",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/start",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameStartReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameStartOK), nil

}

/*
PostVpsServiceNameStop requests the machine to stop

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameStop(params *PostVpsServiceNameStopParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameStopOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameStopParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameStop",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/stop",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameStopReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameStopOK), nil

}

/*
PostVpsServiceNameTerminate terminates your service

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameTerminate(params *PostVpsServiceNameTerminateParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameTerminateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameTerminateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameTerminate",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/terminate",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameTerminateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameTerminateOK), nil

}

/*
PostVpsServiceNameVeeamRestorePointsIDRestore creates a v p s task that will restore the given restore point

PRODUCTION - authentication required
*/
func (a *Client) PostVpsServiceNameVeeamRestorePointsIDRestore(params *PostVpsServiceNameVeeamRestorePointsIDRestoreParams, authInfo runtime.ClientAuthInfoWriter) (*PostVpsServiceNameVeeamRestorePointsIDRestoreOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostVpsServiceNameVeeamRestorePointsIDRestoreParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PostVpsServiceNameVeeamRestorePointsIDRestore",
		Method:             "POST",
		PathPattern:        "/vps/{serviceName}/veeam/restorePoints/{id}/restore",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PostVpsServiceNameVeeamRestorePointsIDRestoreReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PostVpsServiceNameVeeamRestorePointsIDRestoreOK), nil

}

/*
PutVpsServiceName alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceName(params *PutVpsServiceNameParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceName",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameOK), nil

}

/*
PutVpsServiceNameBackupftpAccessIPBlock alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameBackupftpAccessIPBlock(params *PutVpsServiceNameBackupftpAccessIPBlockParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameBackupftpAccessIPBlockOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameBackupftpAccessIPBlockParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameBackupftpAccessIPBlock",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/backupftp/access/{ipBlock}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameBackupftpAccessIPBlockReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameBackupftpAccessIPBlockOK), nil

}

/*
PutVpsServiceNameDisksID alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameDisksID(params *PutVpsServiceNameDisksIDParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameDisksIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameDisksIDParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameDisksID",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/disks/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameDisksIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameDisksIDOK), nil

}

/*
PutVpsServiceNameIpsIPAddress alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameIpsIPAddress(params *PutVpsServiceNameIpsIPAddressParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameIpsIPAddressOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameIpsIPAddressParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameIpsIPAddress",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/ips/{ipAddress}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameIpsIPAddressReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameIpsIPAddressOK), nil

}

/*
PutVpsServiceNameSecondaryDNSDomainsDomain alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameSecondaryDNSDomainsDomain(params *PutVpsServiceNameSecondaryDNSDomainsDomainParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameSecondaryDNSDomainsDomainOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameSecondaryDNSDomainsDomainParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameSecondaryDNSDomainsDomain",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/secondaryDnsDomains/{domain}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameSecondaryDNSDomainsDomainReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameSecondaryDNSDomainsDomainOK), nil

}

/*
PutVpsServiceNameServiceInfos alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameServiceInfos(params *PutVpsServiceNameServiceInfosParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameServiceInfosOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameServiceInfosParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameServiceInfos",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/serviceInfos",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameServiceInfosReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameServiceInfosOK), nil

}

/*
PutVpsServiceNameSnapshot alters this object properties

PRODUCTION - authentication required
*/
func (a *Client) PutVpsServiceNameSnapshot(params *PutVpsServiceNameSnapshotParams, authInfo runtime.ClientAuthInfoWriter) (*PutVpsServiceNameSnapshotOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutVpsServiceNameSnapshotParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "PutVpsServiceNameSnapshot",
		Method:             "PUT",
		PathPattern:        "/vps/{serviceName}/snapshot",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PutVpsServiceNameSnapshotReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PutVpsServiceNameSnapshotOK), nil

}

// SetTransport changes the transport on the client
func (a *Client) SetTransport(transport runtime.ClientTransport) {
	a.transport = transport
}