sites_client.go

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

package sites

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

import (
	"fmt"

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

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

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

// ClientOption is the option for Client methods
type ClientOption func(*runtime.ClientOperation)

// ClientService is the interface for Client methods
type ClientService interface {
	DeleteSitesDevicesiterelations(params *DeleteSitesDevicesiterelationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesDevicesiterelationsOK, error)

	DeleteSitesID(params *DeleteSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesIDOK, error)

	DeleteSitesSiteidImagesImageid(params *DeleteSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesSiteidImagesImageidOK, error)

	GetSites(params *GetSitesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesOK, error)

	GetSitesID(params *GetSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDOK, error)

	GetSitesIDClients(params *GetSitesIDClientsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDClientsOK, error)

	GetSitesIDImages(params *GetSitesIDImagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDImagesOK, error)

	GetSitesSearch(params *GetSitesSearchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSearchOK, error)

	GetSitesSiteidImagesImageid(params *GetSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error

	GetSitesSiteidQos(params *GetSitesSiteidQosParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidQosOK, error)

	GetSitesSiteidSlastats(params *GetSitesSiteidSlastatsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidSlastatsOK, error)

	GetSitesSiteidStatistics(params *GetSitesSiteidStatisticsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidStatisticsOK, error)

	GetSitesSiteidTraffic(params *GetSitesSiteidTrafficParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficOK, error)

	GetSitesSiteidTrafficInterval(params *GetSitesSiteidTrafficIntervalParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficIntervalOK, error)

	GetSitesSiteidTrafficSummary(params *GetSitesSiteidTrafficSummaryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficSummaryOK, error)

	GetSitesTraffic(params *GetSitesTrafficParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesTrafficOK, error)

	PatchSitesSiteidImagesImageid(params *PatchSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchSitesSiteidImagesImageidOK, error)

	PostSites(params *PostSitesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesOK, error)

	PostSitesBulkdelete(params *PostSitesBulkdeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesBulkdeleteOK, error)

	PostSitesDevicesiterelations(params *PostSitesDevicesiterelationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesDevicesiterelationsOK, error)

	PostSitesIDImages(params *PostSitesIDImagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesIDImagesOK, error)

	PostSitesSiteidImagesImageidReorder(params *PostSitesSiteidImagesImageidReorderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidReorderOK, error)

	PostSitesSiteidImagesImageidRotateleft(params *PostSitesSiteidImagesImageidRotateleftParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidRotateleftOK, error)

	PostSitesSiteidImagesImageidRotateright(params *PostSitesSiteidImagesImageidRotaterightParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidRotaterightOK, error)

	PostSitesSiteidSuspend(params *PostSitesSiteidSuspendParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidSuspendOK, error)

	PostSitesSiteidUcrmBind(params *PostSitesSiteidUcrmBindParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUcrmBindOK, error)

	PostSitesSiteidUcrmUnbind(params *PostSitesSiteidUcrmUnbindParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUcrmUnbindOK, error)

	PostSitesSiteidUnsuspend(params *PostSitesSiteidUnsuspendParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUnsuspendOK, error)

	PostSitesUcrmBindings(params *PostSitesUcrmBindingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesUcrmBindingsOK, error)

	PutSitesID(params *PutSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSitesIDOK, error)

	PutSitesSiteidQos(params *PutSitesSiteidQosParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSitesSiteidQosOK, error)

	SetTransport(transport runtime.ClientTransport)
}

/*
  DeleteSitesDevicesiterelations imports sites endpoints and their devices relations
*/
func (a *Client) DeleteSitesDevicesiterelations(params *DeleteSitesDevicesiterelationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesDevicesiterelationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSitesDevicesiterelationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteSitesDevicesiterelations",
		Method:             "DELETE",
		PathPattern:        "/sites/devicesiterelations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteSitesDevicesiterelationsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSitesDevicesiterelationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteSitesDevicesiterelations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteSitesID deletes site it s possible to call only on empty site
*/
func (a *Client) DeleteSitesID(params *DeleteSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSitesIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteSitesId",
		Method:             "DELETE",
		PathPattern:        "/sites/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteSitesIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSitesIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteSitesId: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  DeleteSitesSiteidImagesImageid deletes image
*/
func (a *Client) DeleteSitesSiteidImagesImageid(params *DeleteSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*DeleteSitesSiteidImagesImageidOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSitesSiteidImagesImageidParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "deleteSitesSiteidImagesImageid",
		Method:             "DELETE",
		PathPattern:        "/sites/{siteId}/images/{imageId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DeleteSitesSiteidImagesImageidReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*DeleteSitesSiteidImagesImageidOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for deleteSitesSiteidImagesImageid: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSites lists of sites in UI s p only some combinations of query parameters are valid
*/
func (a *Client) GetSites(params *GetSitesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSites",
		Method:             "GET",
		PathPattern:        "/sites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSites: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesID returns a site s detail
*/
func (a *Client) GetSitesID(params *GetSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesId",
		Method:             "GET",
		PathPattern:        "/sites/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesId: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesIDClients lists of all clients belonging to the given site
*/
func (a *Client) GetSitesIDClients(params *GetSitesIDClientsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDClientsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesIDClientsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesIdClients",
		Method:             "GET",
		PathPattern:        "/sites/{id}/clients",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesIDClientsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesIDClientsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesIdClients: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesIDImages returns all site images sorted by image order
*/
func (a *Client) GetSitesIDImages(params *GetSitesIDImagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesIDImagesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesIDImagesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesIdImages",
		Method:             "GET",
		PathPattern:        "/sites/{id}/images",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesIDImagesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesIDImagesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesIdImages: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSearch searches sites based on name address m a c address or IP address
*/
func (a *Client) GetSitesSearch(params *GetSitesSearchParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSearchOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSearchParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSearch",
		Method:             "GET",
		PathPattern:        "/sites/search",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSearchReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSearchOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSearch: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidImagesImageid returns image file
*/
func (a *Client) GetSitesSiteidImagesImageid(params *GetSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) error {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidImagesImageidParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidImagesImageid",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/images/{imageId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidImagesImageidReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	_, err := a.transport.Submit(op)
	if err != nil {
		return err
	}
	return nil
}

/*
  GetSitesSiteidQos gets client traffic shaping
*/
func (a *Client) GetSitesSiteidQos(params *GetSitesSiteidQosParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidQosOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidQosParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidQos",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/qos",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidQosReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidQosOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidQos: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidSlastats gets SLA stats for a subscriber this endpoint s purpose is i s p and SLA score debugging
*/
func (a *Client) GetSitesSiteidSlastats(params *GetSitesSiteidSlastatsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidSlastatsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidSlastatsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidSlastats",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/slastats",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidSlastatsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidSlastatsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidSlastats: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidStatistics gets upload and download between site and its parent site
*/
func (a *Client) GetSitesSiteidStatistics(params *GetSitesSiteidStatisticsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidStatisticsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidStatisticsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidStatistics",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/statistics",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidStatisticsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidStatisticsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidStatistics: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidTraffic gets site traffic between two points in time
*/
func (a *Client) GetSitesSiteidTraffic(params *GetSitesSiteidTrafficParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidTrafficParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidTraffic",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/traffic",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidTrafficReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidTrafficOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidTraffic: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidTrafficInterval gets site traffic for specified interval up to now
*/
func (a *Client) GetSitesSiteidTrafficInterval(params *GetSitesSiteidTrafficIntervalParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficIntervalOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidTrafficIntervalParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidTrafficInterval",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/traffic/interval",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidTrafficIntervalReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidTrafficIntervalOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidTrafficInterval: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesSiteidTrafficSummary gets site total upload and download for specified interval up to now
*/
func (a *Client) GetSitesSiteidTrafficSummary(params *GetSitesSiteidTrafficSummaryParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesSiteidTrafficSummaryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesSiteidTrafficSummaryParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesSiteidTrafficSummary",
		Method:             "GET",
		PathPattern:        "/sites/{siteId}/traffic/summary",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesSiteidTrafficSummaryReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesSiteidTrafficSummaryOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesSiteidTrafficSummary: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  GetSitesTraffic gets traffic from each site between two points in time
*/
func (a *Client) GetSitesTraffic(params *GetSitesTrafficParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*GetSitesTrafficOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSitesTrafficParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "getSitesTraffic",
		Method:             "GET",
		PathPattern:        "/sites/traffic",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &GetSitesTrafficReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*GetSitesTrafficOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for getSitesTraffic: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PatchSitesSiteidImagesImageid updates image
*/
func (a *Client) PatchSitesSiteidImagesImageid(params *PatchSitesSiteidImagesImageidParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PatchSitesSiteidImagesImageidOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSitesSiteidImagesImageidParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "patchSitesSiteidImagesImageid",
		Method:             "PATCH",
		PathPattern:        "/sites/{siteId}/images/{imageId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PatchSitesSiteidImagesImageidReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PatchSitesSiteidImagesImageidOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for patchSitesSiteidImagesImageid: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSites creates new site
*/
func (a *Client) PostSites(params *PostSitesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSites",
		Method:             "POST",
		PathPattern:        "/sites",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSites: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesBulkdelete deletes sites it s possible to call only on empty sites
*/
func (a *Client) PostSitesBulkdelete(params *PostSitesBulkdeleteParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesBulkdeleteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesBulkdeleteParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesBulkdelete",
		Method:             "POST",
		PathPattern:        "/sites/bulkdelete",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesBulkdeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesBulkdeleteOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesBulkdelete: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesDevicesiterelations imports sites endpoints and their devices relations
*/
func (a *Client) PostSitesDevicesiterelations(params *PostSitesDevicesiterelationsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesDevicesiterelationsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesDevicesiterelationsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesDevicesiterelations",
		Method:             "POST",
		PathPattern:        "/sites/devicesiterelations",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesDevicesiterelationsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesDevicesiterelationsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesDevicesiterelations: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesIDImages uploads new image and create image thumbnail
*/
func (a *Client) PostSitesIDImages(params *PostSitesIDImagesParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesIDImagesOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesIDImagesParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesIdImages",
		Method:             "POST",
		PathPattern:        "/sites/{id}/images",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesIDImagesReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesIDImagesOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesIdImages: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidImagesImageidReorder changes image order
*/
func (a *Client) PostSitesSiteidImagesImageidReorder(params *PostSitesSiteidImagesImageidReorderParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidReorderOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidImagesImageidReorderParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidImagesImageidReorder",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/images/{imageId}/reorder",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidImagesImageidReorderReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidImagesImageidReorderOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidImagesImageidReorder: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidImagesImageidRotateleft rotates the image 90 degrees to left
*/
func (a *Client) PostSitesSiteidImagesImageidRotateleft(params *PostSitesSiteidImagesImageidRotateleftParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidRotateleftOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidImagesImageidRotateleftParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidImagesImageidRotateleft",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/images/{imageId}/rotateleft",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidImagesImageidRotateleftReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidImagesImageidRotateleftOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidImagesImageidRotateleft: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidImagesImageidRotateright rotates the image 90 degrees to right
*/
func (a *Client) PostSitesSiteidImagesImageidRotateright(params *PostSitesSiteidImagesImageidRotaterightParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidImagesImageidRotaterightOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidImagesImageidRotaterightParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidImagesImageidRotateright",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/images/{imageId}/rotateright",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidImagesImageidRotaterightReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidImagesImageidRotaterightOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidImagesImageidRotateright: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidSuspend suspends client
*/
func (a *Client) PostSitesSiteidSuspend(params *PostSitesSiteidSuspendParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidSuspendOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidSuspendParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidSuspend",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/suspend",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidSuspendReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidSuspendOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidSuspend: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidUcrmBind binds u c r m services and UI s p site
*/
func (a *Client) PostSitesSiteidUcrmBind(params *PostSitesSiteidUcrmBindParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUcrmBindOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidUcrmBindParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidUcrmBind",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/ucrm/bind",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidUcrmBindReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidUcrmBindOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidUcrmBind: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidUcrmUnbind unbinds u c r m services and UI s p site
*/
func (a *Client) PostSitesSiteidUcrmUnbind(params *PostSitesSiteidUcrmUnbindParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUcrmUnbindOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidUcrmUnbindParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidUcrmUnbind",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/ucrm/unbind",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidUcrmUnbindReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidUcrmUnbindOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidUcrmUnbind: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesSiteidUnsuspend unsuspends client
*/
func (a *Client) PostSitesSiteidUnsuspend(params *PostSitesSiteidUnsuspendParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesSiteidUnsuspendOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesSiteidUnsuspendParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesSiteidUnsuspend",
		Method:             "POST",
		PathPattern:        "/sites/{siteId}/unsuspend",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesSiteidUnsuspendReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesSiteidUnsuspendOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesSiteidUnsuspend: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PostSitesUcrmBindings imports UI s p sites to u c r m services relations description
*/
func (a *Client) PostSitesUcrmBindings(params *PostSitesUcrmBindingsParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PostSitesUcrmBindingsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPostSitesUcrmBindingsParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "postSitesUcrmBindings",
		Method:             "POST",
		PathPattern:        "/sites/ucrm/bindings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PostSitesUcrmBindingsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PostSitesUcrmBindingsOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for postSitesUcrmBindings: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PutSitesID updates site
*/
func (a *Client) PutSitesID(params *PutSitesIDParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSitesIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSitesIDParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "putSitesId",
		Method:             "PUT",
		PathPattern:        "/sites/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PutSitesIDReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSitesIDOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for putSitesId: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

/*
  PutSitesSiteidQos updates client traffic shaping
*/
func (a *Client) PutSitesSiteidQos(params *PutSitesSiteidQosParams, authInfo runtime.ClientAuthInfoWriter, opts ...ClientOption) (*PutSitesSiteidQosOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPutSitesSiteidQosParams()
	}
	op := &runtime.ClientOperation{
		ID:                 "putSitesSiteidQos",
		Method:             "PUT",
		PathPattern:        "/sites/{siteId}/qos",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &PutSitesSiteidQosReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	}
	for _, opt := range opts {
		opt(op)
	}

	result, err := a.transport.Submit(op)
	if err != nil {
		return nil, err
	}
	success, ok := result.(*PutSitesSiteidQosOK)
	if ok {
		return success, nil
	}
	// unexpected success response
	// safeguard: normally, absent a default response, unknown success responses return an error above: so this is a codegen issue
	msg := fmt.Sprintf("unexpected success response for putSitesSiteidQos: API contract not enforced by server. Client expected to get an error, but got: %T", result)
	panic(msg)
}

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