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

package lm

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

import (
	"io"
	"reflect"

	"github.com/go-openapi/runtime"

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

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

/*
Client for lm API
*/
type Client struct {
	transport runtime.ClientTransport
	formats   strfmt.Registry
	authInfo  runtime.ClientAuthInfoWriter
	userAgent *string
}

/*
AckAlertByID acks alert by id
*/
func (a *Client) AckAlertByID(params *AckAlertByIDParams) (*AckAlertByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAckAlertByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ackAlertById",
		Method:             "POST",
		PathPattern:        "/alert/alerts/{id}/ack",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AckAlertByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AckAlertByIDOK), nil

}

/*
AckCollectorDownAlertByID acks collector down alert
*/
func (a *Client) AckCollectorDownAlertByID(params *AckCollectorDownAlertByIDParams) (*AckCollectorDownAlertByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAckCollectorDownAlertByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "ackCollectorDownAlertById",
		Method:             "POST",
		PathPattern:        "/setting/collector/collectors/{id}/ackdown",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AckCollectorDownAlertByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AckCollectorDownAlertByIDOK), nil

}

/*
AddAdmin adds user
*/
func (a *Client) AddAdmin(params *AddAdminParams) (*AddAdminOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddAdminParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddAlertNoteByID adds alert note
*/
func (a *Client) AddAlertNoteByID(params *AddAlertNoteByIDParams) (*AddAlertNoteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddAlertNoteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addAlertNoteById",
		Method:             "POST",
		PathPattern:        "/alert/alerts/{id}/note",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddAlertNoteByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddAlertNoteByIDOK), nil

}

/*
AddAlertRule adds alert rule
*/
func (a *Client) AddAlertRule(params *AddAlertRuleParams) (*AddAlertRuleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddAlertRuleParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addAlertRule",
		Method:             "POST",
		PathPattern:        "/setting/alert/rules",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddAlertRuleReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddAlertRuleOK), nil

}

/*
AddAPITokenByAdminID adds api tokens for a user
*/
func (a *Client) AddAPITokenByAdminID(params *AddAPITokenByAdminIDParams) (*AddAPITokenByAdminIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddAPITokenByAdminIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addApiTokenByAdminId",
		Method:             "POST",
		PathPattern:        "/setting/admins/{adminId}/apitokens",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddAPITokenByAdminIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddAPITokenByAdminIDOK), nil

}

/*
AddAppliesToFunction adds applies to function
*/
func (a *Client) AddAppliesToFunction(params *AddAppliesToFunctionParams) (*AddAppliesToFunctionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddAppliesToFunctionParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddCollector adds collector
*/
func (a *Client) AddCollector(params *AddCollectorParams) (*AddCollectorOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddCollectorParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addCollector",
		Method:             "POST",
		PathPattern:        "/setting/collector/collectors",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddCollectorReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddCollectorOK), nil

}

/*
AddCollectorGroup adds collector group
*/
func (a *Client) AddCollectorGroup(params *AddCollectorGroupParams) (*AddCollectorGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddCollectorGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addCollectorGroup",
		Method:             "POST",
		PathPattern:        "/setting/collector/groups",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddCollectorGroupReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddCollectorGroupOK), nil

}

/*
AddDashboard adds dashboard
*/
func (a *Client) AddDashboard(params *AddDashboardParams) (*AddDashboardOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDashboardParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddDashboardGroup adds dashboard group
*/
func (a *Client) AddDashboardGroup(params *AddDashboardGroupParams) (*AddDashboardGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDashboardGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddDevice adds a new device
*/
func (a *Client) AddDevice(params *AddDeviceParams) (*AddDeviceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddDeviceDatasourceInstance adds device instance
*/
func (a *Client) AddDeviceDatasourceInstance(params *AddDeviceDatasourceInstanceParams) (*AddDeviceDatasourceInstanceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceDatasourceInstanceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addDeviceDatasourceInstance",
		Method:             "POST",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddDeviceDatasourceInstanceReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddDeviceDatasourceInstanceOK), nil

}

/*
AddDeviceDatasourceInstanceGroup adds device datasource instance group
*/
func (a *Client) AddDeviceDatasourceInstanceGroup(params *AddDeviceDatasourceInstanceGroupParams) (*AddDeviceDatasourceInstanceGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceDatasourceInstanceGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addDeviceDatasourceInstanceGroup",
		Method:             "POST",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddDeviceDatasourceInstanceGroupReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddDeviceDatasourceInstanceGroupOK), nil

}

/*
AddDeviceGroup adds device group
*/
func (a *Client) AddDeviceGroup(params *AddDeviceGroupParams) (*AddDeviceGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddDeviceGroupClusterAlertConf adds cluster alert configuration
*/
func (a *Client) AddDeviceGroupClusterAlertConf(params *AddDeviceGroupClusterAlertConfParams) (*AddDeviceGroupClusterAlertConfOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceGroupClusterAlertConfParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addDeviceGroupClusterAlertConf",
		Method:             "POST",
		PathPattern:        "/device/groups/{deviceGroupId}/clusterAlertConf",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddDeviceGroupClusterAlertConfReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddDeviceGroupClusterAlertConfOK), nil

}

/*
AddDeviceGroupProperty adds device group property
*/
func (a *Client) AddDeviceGroupProperty(params *AddDeviceGroupPropertyParams) (*AddDeviceGroupPropertyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDeviceGroupPropertyParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addDeviceGroupProperty",
		Method:             "POST",
		PathPattern:        "/device/groups/{gid}/properties",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddDeviceGroupPropertyReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddDeviceGroupPropertyOK), nil

}

/*
AddDeviceProperty adds device property
*/
func (a *Client) AddDeviceProperty(params *AddDevicePropertyParams) (*AddDevicePropertyOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddDevicePropertyParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addDeviceProperty",
		Method:             "POST",
		PathPattern:        "/device/devices/{deviceId}/properties",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddDevicePropertyReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddDevicePropertyOK), nil

}

/*
AddEscalationChain adds escalation chain
*/
func (a *Client) AddEscalationChain(params *AddEscalationChainParams) (*AddEscalationChainOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddEscalationChainParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "addEscalationChain",
		Method:             "POST",
		PathPattern:        "/setting/alert/chains",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &AddEscalationChainReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*AddEscalationChainOK), nil

}

/*
AddNetscan adds a new netscan
*/
func (a *Client) AddNetscan(params *AddNetscanParams) (*AddNetscanOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddNetscanParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddOpsNote adds opsnote
*/
func (a *Client) AddOpsNote(params *AddOpsNoteParams) (*AddOpsNoteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddOpsNoteParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddRecipientGroup adds recipient group
*/
func (a *Client) AddRecipientGroup(params *AddRecipientGroupParams) (*AddRecipientGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddRecipientGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddReport adds report
*/
func (a *Client) AddReport(params *AddReportParams) (*AddReportOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddReportParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddReportGroup adds report group
*/
func (a *Client) AddReportGroup(params *AddReportGroupParams) (*AddReportGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddReportGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddRole adds role
*/
func (a *Client) AddRole(params *AddRoleParams) (*AddRoleOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddRoleParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddSDT adds SDT
*/
func (a *Client) AddSDT(params *AddSDTParams) (*AddSDTOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddSDTParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddWebsite adds website
*/
func (a *Client) AddWebsite(params *AddWebsiteParams) (*AddWebsiteOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddWebsiteParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddWebsiteGroup adds website group
*/
func (a *Client) AddWebsiteGroup(params *AddWebsiteGroupParams) (*AddWebsiteGroupOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddWebsiteGroupParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
AddWidget adds widget
*/
func (a *Client) AddWidget(params *AddWidgetParams) (*AddWidgetOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewAddWidgetParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
CollectDeviceConfigSourceConfig collects a config for a device
*/
func (a *Client) CollectDeviceConfigSourceConfig(params *CollectDeviceConfigSourceConfigParams) (*CollectDeviceConfigSourceConfigOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewCollectDeviceConfigSourceConfigParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "collectDeviceConfigSourceConfig",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/config/collectNow",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &CollectDeviceConfigSourceConfigReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*CollectDeviceConfigSourceConfigOK), nil

}

/*
DeleteAdminByID deletes user
*/
func (a *Client) DeleteAdminByID(params *DeleteAdminByIDParams) (*DeleteAdminByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAdminByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteAdminById",
		Method:             "DELETE",
		PathPattern:        "/setting/admins/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteAdminByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteAdminByIDOK), nil

}

/*
DeleteAlertRuleByID deletes alert rule
*/
func (a *Client) DeleteAlertRuleByID(params *DeleteAlertRuleByIDParams) (*DeleteAlertRuleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAlertRuleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteAlertRuleById",
		Method:             "DELETE",
		PathPattern:        "/setting/alert/rules/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteAlertRuleByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteAlertRuleByIDOK), nil

}

/*
DeleteAPITokenByID deletes api token
*/
func (a *Client) DeleteAPITokenByID(params *DeleteAPITokenByIDParams) (*DeleteAPITokenByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAPITokenByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteApiTokenById",
		Method:             "DELETE",
		PathPattern:        "/setting/admins/{adminId}/apitokens/{apitokenId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteAPITokenByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteAPITokenByIDOK), nil

}

/*
DeleteAppliesToFunctionByID deletes applies to function
*/
func (a *Client) DeleteAppliesToFunctionByID(params *DeleteAppliesToFunctionByIDParams) (*DeleteAppliesToFunctionByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteAppliesToFunctionByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteAppliesToFunctionById",
		Method:             "DELETE",
		PathPattern:        "/setting/functions/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteAppliesToFunctionByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteAppliesToFunctionByIDOK), nil

}

/*
DeleteCollectorByID deletes collector
*/
func (a *Client) DeleteCollectorByID(params *DeleteCollectorByIDParams) (*DeleteCollectorByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCollectorByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteCollectorById",
		Method:             "DELETE",
		PathPattern:        "/setting/collector/collectors/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteCollectorByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteCollectorByIDOK), nil

}

/*
DeleteCollectorGroupByID deletes collector group
*/
func (a *Client) DeleteCollectorGroupByID(params *DeleteCollectorGroupByIDParams) (*DeleteCollectorGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteCollectorGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteCollectorGroupById",
		Method:             "DELETE",
		PathPattern:        "/setting/collector/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteCollectorGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteCollectorGroupByIDOK), nil

}

/*
DeleteDashboardByID deletes dashboard
*/
func (a *Client) DeleteDashboardByID(params *DeleteDashboardByIDParams) (*DeleteDashboardByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDashboardByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDashboardById",
		Method:             "DELETE",
		PathPattern:        "/dashboard/dashboards/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDashboardByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDashboardByIDOK), nil

}

/*
DeleteDashboardGroupByID deletes dashboard group
*/
func (a *Client) DeleteDashboardGroupByID(params *DeleteDashboardGroupByIDParams) (*DeleteDashboardGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDashboardGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDashboardGroupById",
		Method:             "DELETE",
		PathPattern:        "/dashboard/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDashboardGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDashboardGroupByIDOK), nil

}

/*
DeleteDatasourceByID deletes datasource
*/
func (a *Client) DeleteDatasourceByID(params *DeleteDatasourceByIDParams) (*DeleteDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDatasourceById",
		Method:             "DELETE",
		PathPattern:        "/setting/datasources/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDatasourceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDatasourceByIDOK), nil

}

/*
DeleteDeviceByID deletes a device
*/
func (a *Client) DeleteDeviceByID(params *DeleteDeviceByIDParams) (*DeleteDeviceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDeviceById",
		Method:             "DELETE",
		PathPattern:        "/device/devices/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDeviceByIDOK), nil

}

/*
DeleteDeviceDatasourceInstanceByID deletes a device instance
*/
func (a *Client) DeleteDeviceDatasourceInstanceByID(params *DeleteDeviceDatasourceInstanceByIDParams) (*DeleteDeviceDatasourceInstanceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceDatasourceInstanceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDeviceDatasourceInstanceById",
		Method:             "DELETE",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceDatasourceInstanceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDeviceDatasourceInstanceByIDOK), nil

}

/*
DeleteDeviceGroupByID deletes device group
*/
func (a *Client) DeleteDeviceGroupByID(params *DeleteDeviceGroupByIDParams) (*DeleteDeviceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDeviceGroupById",
		Method:             "DELETE",
		PathPattern:        "/device/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDeviceGroupByIDOK), nil

}

/*
DeleteDeviceGroupClusterAlertConfByID deletes cluster alert configuration
*/
func (a *Client) DeleteDeviceGroupClusterAlertConfByID(params *DeleteDeviceGroupClusterAlertConfByIDParams) (*DeleteDeviceGroupClusterAlertConfByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceGroupClusterAlertConfByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDeviceGroupClusterAlertConfById",
		Method:             "DELETE",
		PathPattern:        "/device/groups/{deviceGroupId}/clusterAlertConf/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceGroupClusterAlertConfByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDeviceGroupClusterAlertConfByIDOK), nil

}

/*
DeleteDeviceGroupPropertyByName deletes device group property
*/
func (a *Client) DeleteDeviceGroupPropertyByName(params *DeleteDeviceGroupPropertyByNameParams) (*DeleteDeviceGroupPropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDeviceGroupPropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDeviceGroupPropertyByName",
		Method:             "DELETE",
		PathPattern:        "/device/groups/{gid}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDeviceGroupPropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDeviceGroupPropertyByNameOK), nil

}

/*
DeleteDevicePropertyByName deletes device property
*/
func (a *Client) DeleteDevicePropertyByName(params *DeleteDevicePropertyByNameParams) (*DeleteDevicePropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteDevicePropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteDevicePropertyByName",
		Method:             "DELETE",
		PathPattern:        "/device/devices/{deviceId}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteDevicePropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteDevicePropertyByNameOK), nil

}

/*
DeleteEscalationChainByID deletes escalation chain
*/
func (a *Client) DeleteEscalationChainByID(params *DeleteEscalationChainByIDParams) (*DeleteEscalationChainByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteEscalationChainByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteEscalationChainById",
		Method:             "DELETE",
		PathPattern:        "/setting/alert/chains/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteEscalationChainByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteEscalationChainByIDOK), nil

}

/*
DeleteNetscanByID deletes a netscan
*/
func (a *Client) DeleteNetscanByID(params *DeleteNetscanByIDParams) (*DeleteNetscanByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteNetscanByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteNetscanById",
		Method:             "DELETE",
		PathPattern:        "/setting/netscans/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteNetscanByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteNetscanByIDOK), nil

}

/*
DeleteOpsNoteByID deletes opsnote
*/
func (a *Client) DeleteOpsNoteByID(params *DeleteOpsNoteByIDParams) (*DeleteOpsNoteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteOpsNoteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteOpsNoteById",
		Method:             "DELETE",
		PathPattern:        "/setting/opsnotes/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteOpsNoteByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteOpsNoteByIDOK), nil

}

/*
DeleteRecipientGroupByID deletes recipient group
*/
func (a *Client) DeleteRecipientGroupByID(params *DeleteRecipientGroupByIDParams) (*DeleteRecipientGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteRecipientGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteRecipientGroupById",
		Method:             "DELETE",
		PathPattern:        "/setting/recipientgroups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteRecipientGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteRecipientGroupByIDOK), nil

}

/*
DeleteReportByID deletes report
*/
func (a *Client) DeleteReportByID(params *DeleteReportByIDParams) (*DeleteReportByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteReportByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteReportById",
		Method:             "DELETE",
		PathPattern:        "/report/reports/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteReportByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteReportByIDOK), nil

}

/*
DeleteReportGroupByID deletes report group
*/
func (a *Client) DeleteReportGroupByID(params *DeleteReportGroupByIDParams) (*DeleteReportGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteReportGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteReportGroupById",
		Method:             "DELETE",
		PathPattern:        "/report/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteReportGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteReportGroupByIDOK), nil

}

/*
DeleteRoleByID deletes role
*/
func (a *Client) DeleteRoleByID(params *DeleteRoleByIDParams) (*DeleteRoleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteRoleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteRoleById",
		Method:             "DELETE",
		PathPattern:        "/setting/roles/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteRoleByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteRoleByIDOK), nil

}

/*
DeleteSDTByID deletes SDT
*/
func (a *Client) DeleteSDTByID(params *DeleteSDTByIDParams) (*DeleteSDTByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteSDTByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteSDTById",
		Method:             "DELETE",
		PathPattern:        "/sdt/sdts/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteSDTByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteSDTByIDOK), nil

}

/*
DeleteWebsiteByID deletes website
*/
func (a *Client) DeleteWebsiteByID(params *DeleteWebsiteByIDParams) (*DeleteWebsiteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteWebsiteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteWebsiteById",
		Method:             "DELETE",
		PathPattern:        "/website/websites/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteWebsiteByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteWebsiteByIDOK), nil

}

/*
DeleteWebsiteGroupByID deletes website group
*/
func (a *Client) DeleteWebsiteGroupByID(params *DeleteWebsiteGroupByIDParams) (*DeleteWebsiteGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteWebsiteGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteWebsiteGroupById",
		Method:             "DELETE",
		PathPattern:        "/website/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteWebsiteGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteWebsiteGroupByIDOK), nil

}

/*
DeleteWidgetByID deletes widget
*/
func (a *Client) DeleteWidgetByID(params *DeleteWidgetByIDParams) (*DeleteWidgetByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDeleteWidgetByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "deleteWidgetById",
		Method:             "DELETE",
		PathPattern:        "/dashboard/widgets/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &DeleteWidgetByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DeleteWidgetByIDOK), nil

}

/*
ExecuteDebugCommand executes a collector debug command
*/
func (a *Client) ExecuteDebugCommand(params *ExecuteDebugCommandParams) (*ExecuteDebugCommandOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewExecuteDebugCommandParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
FetchDeviceInstancesData fetches device instances data
*/
func (a *Client) FetchDeviceInstancesData(params *FetchDeviceInstancesDataParams) (*FetchDeviceInstancesDataOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewFetchDeviceInstancesDataParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "fetchDeviceInstancesData",
		Method:             "POST",
		PathPattern:        "/device/instances/datafetch",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &FetchDeviceInstancesDataReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*FetchDeviceInstancesDataOK), nil

}

/*
GenerateReportByID runs a report
*/
func (a *Client) GenerateReportByID(params *GenerateReportByIDParams) (*GenerateReportByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGenerateReportByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "generateReportById",
		Method:             "POST",
		PathPattern:        "/report/reports/{id}/executions",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GenerateReportByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GenerateReportByIDOK), nil

}

/*
GetAdminByID gets user
*/
func (a *Client) GetAdminByID(params *GetAdminByIDParams) (*GetAdminByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAdminByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAdminList gets user list
*/
func (a *Client) GetAdminList(params *GetAdminListParams) (*GetAdminListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAdminListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertByID gets alert
*/
func (a *Client) GetAlertByID(params *GetAlertByIDParams) (*GetAlertByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertList gets alert list
*/
func (a *Client) GetAlertList(params *GetAlertListParams) (*GetAlertListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertListByDeviceGroupID gets device group alerts
*/
func (a *Client) GetAlertListByDeviceGroupID(params *GetAlertListByDeviceGroupIDParams) (*GetAlertListByDeviceGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertListByDeviceGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertListByDeviceID gets alerts
*/
func (a *Client) GetAlertListByDeviceID(params *GetAlertListByDeviceIDParams) (*GetAlertListByDeviceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertListByDeviceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertRuleByID gets alert rule by id
*/
func (a *Client) GetAlertRuleByID(params *GetAlertRuleByIDParams) (*GetAlertRuleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertRuleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAlertRuleList gets alert rule list
*/
func (a *Client) GetAlertRuleList(params *GetAlertRuleListParams) (*GetAlertRuleListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAlertRuleListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAllSDTListByDeviceID gets s d ts for a device
*/
func (a *Client) GetAllSDTListByDeviceID(params *GetAllSDTListByDeviceIDParams) (*GetAllSDTListByDeviceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAllSDTListByDeviceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAllSDTListByWebsiteGroupID gets a list of s d ts for a website group
*/
func (a *Client) GetAllSDTListByWebsiteGroupID(params *GetAllSDTListByWebsiteGroupIDParams) (*GetAllSDTListByWebsiteGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAllSDTListByWebsiteGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAPITokenList gets a list of api tokens across users
*/
func (a *Client) GetAPITokenList(params *GetAPITokenListParams) (*GetAPITokenListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAPITokenListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAPITokenListByAdminID gets api tokens for a user
*/
func (a *Client) GetAPITokenListByAdminID(params *GetAPITokenListByAdminIDParams) (*GetAPITokenListByAdminIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAPITokenListByAdminIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAppliesToFunctionByID gets applies to function
*/
func (a *Client) GetAppliesToFunctionByID(params *GetAppliesToFunctionByIDParams) (*GetAppliesToFunctionByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAppliesToFunctionByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAppliesToFunctionList gets applies to function list
*/
func (a *Client) GetAppliesToFunctionList(params *GetAppliesToFunctionListParams) (*GetAppliesToFunctionListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAppliesToFunctionListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAssociatedDeviceListByDataSourceID gets devices associated with a datasource
*/
func (a *Client) GetAssociatedDeviceListByDataSourceID(params *GetAssociatedDeviceListByDataSourceIDParams) (*GetAssociatedDeviceListByDataSourceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAssociatedDeviceListByDataSourceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAuditLogByID gets audit log by id
*/
func (a *Client) GetAuditLogByID(params *GetAuditLogByIDParams) (*GetAuditLogByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAuditLogByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAuditLogList gets audit logs
*/
func (a *Client) GetAuditLogList(params *GetAuditLogListParams) (*GetAuditLogListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAuditLogListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetAwsExternalID gets a w s external id
*/
func (a *Client) GetAwsExternalID(params *GetAwsExternalIDParams) (*GetAwsExternalIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetAwsExternalIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetCollectorByID gets collector
*/
func (a *Client) GetCollectorByID(params *GetCollectorByIDParams) (*GetCollectorByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetCollectorGroupByID gets collector group
*/
func (a *Client) GetCollectorGroupByID(params *GetCollectorGroupByIDParams) (*GetCollectorGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetCollectorGroupList gets collector group list
*/
func (a *Client) GetCollectorGroupList(params *GetCollectorGroupListParams) (*GetCollectorGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetCollectorInstaller gets collector installer
*/
func (a *Client) GetCollectorInstaller(params *GetCollectorInstallerParams, writer io.Writer) (*GetCollectorInstallerOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorInstallerParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getCollectorInstaller",
		Method:             "GET",
		PathPattern:        "/setting/collector/collectors/{collectorId}/installers/{osAndArch}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetCollectorInstallerReader{formats: a.formats, writer: writer},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetCollectorInstallerOK), nil

}

/*
GetCollectorList gets collector list
*/
func (a *Client) GetCollectorList(params *GetCollectorListParams) (*GetCollectorListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetCollectorVersionList gets collector version list
*/
func (a *Client) GetCollectorVersionList(params *GetCollectorVersionListParams) (*GetCollectorVersionListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetCollectorVersionListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDashboardByID gets dashboard
*/
func (a *Client) GetDashboardByID(params *GetDashboardByIDParams) (*GetDashboardByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDashboardGroupByID gets dashboard group
*/
func (a *Client) GetDashboardGroupByID(params *GetDashboardGroupByIDParams) (*GetDashboardGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDashboardGroupList gets dashboard group list
*/
func (a *Client) GetDashboardGroupList(params *GetDashboardGroupListParams) (*GetDashboardGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDashboardList gets dashboard list
*/
func (a *Client) GetDashboardList(params *GetDashboardListParams) (*GetDashboardListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDashboardListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDataSourceOverviewGraphByID gets datasource overview graph by id
*/
func (a *Client) GetDataSourceOverviewGraphByID(params *GetDataSourceOverviewGraphByIDParams) (*GetDataSourceOverviewGraphByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDataSourceOverviewGraphByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDataSourceOverviewGraphById",
		Method:             "GET",
		PathPattern:        "/setting/datasources/{dsId}/ographs/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDataSourceOverviewGraphByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDataSourceOverviewGraphByIDOK), nil

}

/*
GetDataSourceOverviewGraphList gets datasource overview graph list
*/
func (a *Client) GetDataSourceOverviewGraphList(params *GetDataSourceOverviewGraphListParams) (*GetDataSourceOverviewGraphListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDataSourceOverviewGraphListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDatasourceByID gets datasource by id
*/
func (a *Client) GetDatasourceByID(params *GetDatasourceByIDParams) (*GetDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDatasourceList gets datasource list
*/
func (a *Client) GetDatasourceList(params *GetDatasourceListParams) (*GetDatasourceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDatasourceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDebugCommandResult gets the result of a collector debug command
*/
func (a *Client) GetDebugCommandResult(params *GetDebugCommandResultParams) (*GetDebugCommandResultOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDebugCommandResultParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceByID gets device by id
*/
func (a *Client) GetDeviceByID(params *GetDeviceByIDParams) (*GetDeviceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceConfigSourceConfigByID gets a config for a device
*/
func (a *Client) GetDeviceConfigSourceConfigByID(params *GetDeviceConfigSourceConfigByIDParams) (*GetDeviceConfigSourceConfigByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceConfigSourceConfigByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceConfigSourceConfigById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/config/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceConfigSourceConfigByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceConfigSourceConfigByIDOK), nil

}

/*
GetDeviceConfigSourceConfigList gets detailed config information for the instance
*/
func (a *Client) GetDeviceConfigSourceConfigList(params *GetDeviceConfigSourceConfigListParams) (*GetDeviceConfigSourceConfigListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceConfigSourceConfigListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceConfigSourceConfigList",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/config",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceConfigSourceConfigListReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceConfigSourceConfigListOK), nil

}

/*
GetDeviceDatasourceByID gets device datasource
*/
func (a *Client) GetDeviceDatasourceByID(params *GetDeviceDatasourceByIDParams) (*GetDeviceDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceByIDOK), nil

}

/*
GetDeviceDatasourceDataByID gets device datasource data
*/
func (a *Client) GetDeviceDatasourceDataByID(params *GetDeviceDatasourceDataByIDParams) (*GetDeviceDatasourceDataByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceDataByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceDataById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{id}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceDataByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceDataByIDOK), nil

}

/*
GetDeviceDatasourceInstanceAlertSettingByID gets device instance alert setting
*/
func (a *Client) GetDeviceDatasourceInstanceAlertSettingByID(params *GetDeviceDatasourceInstanceAlertSettingByIDParams) (*GetDeviceDatasourceInstanceAlertSettingByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceAlertSettingByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceAlertSettingById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/alertsettings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceAlertSettingByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceAlertSettingByIDOK), nil

}

/*
GetDeviceDatasourceInstanceAlertSettingListOfDSI gets a list of alert settings for a device datasource instance
*/
func (a *Client) GetDeviceDatasourceInstanceAlertSettingListOfDSI(params *GetDeviceDatasourceInstanceAlertSettingListOfDSIParams) (*GetDeviceDatasourceInstanceAlertSettingListOfDSIOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceAlertSettingListOfDSIParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceAlertSettingListOfDSI",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/alertsettings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceAlertSettingListOfDSIReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceAlertSettingListOfDSIOK), nil

}

/*
GetDeviceDatasourceInstanceAlertSettingListOfDevice gets a list of alert settings for a device
*/
func (a *Client) GetDeviceDatasourceInstanceAlertSettingListOfDevice(params *GetDeviceDatasourceInstanceAlertSettingListOfDeviceParams) (*GetDeviceDatasourceInstanceAlertSettingListOfDeviceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceAlertSettingListOfDeviceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceDatasourceInstanceByID gets device instance
*/
func (a *Client) GetDeviceDatasourceInstanceByID(params *GetDeviceDatasourceInstanceByIDParams) (*GetDeviceDatasourceInstanceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceByIDOK), nil

}

/*
GetDeviceDatasourceInstanceData gets device instance data
*/
func (a *Client) GetDeviceDatasourceInstanceData(params *GetDeviceDatasourceInstanceDataParams) (*GetDeviceDatasourceInstanceDataOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceDataParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceData",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceDataReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceDataOK), nil

}

/*
GetDeviceDatasourceInstanceGraphData gets device instance graph data
*/
func (a *Client) GetDeviceDatasourceInstanceGraphData(params *GetDeviceDatasourceInstanceGraphDataParams) (*GetDeviceDatasourceInstanceGraphDataOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceGraphDataParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceGraphData",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}/graphs/{graphId}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceGraphDataReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceGraphDataOK), nil

}

/*
GetDeviceDatasourceInstanceGroupByID gets device datasource instance group
*/
func (a *Client) GetDeviceDatasourceInstanceGroupByID(params *GetDeviceDatasourceInstanceGroupByIDParams) (*GetDeviceDatasourceInstanceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceGroupById",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceGroupByIDOK), nil

}

/*
GetDeviceDatasourceInstanceGroupList gets device datasource instance group list
*/
func (a *Client) GetDeviceDatasourceInstanceGroupList(params *GetDeviceDatasourceInstanceGroupListParams) (*GetDeviceDatasourceInstanceGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceGroupList",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceGroupListReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceGroupListOK), nil

}

/*
GetDeviceDatasourceInstanceGroupOverviewGraphData gets device instance group overview graph data
*/
func (a *Client) GetDeviceDatasourceInstanceGroupOverviewGraphData(params *GetDeviceDatasourceInstanceGroupOverviewGraphDataParams) (*GetDeviceDatasourceInstanceGroupOverviewGraphDataOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceGroupOverviewGraphDataParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceGroupOverviewGraphData",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups/{dsigId}/graphs/{ographId}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceGroupOverviewGraphDataReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceGroupOverviewGraphDataOK), nil

}

/*
GetDeviceDatasourceInstanceList gets device instance list
*/
func (a *Client) GetDeviceDatasourceInstanceList(params *GetDeviceDatasourceInstanceListParams) (*GetDeviceDatasourceInstanceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceList",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceListReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceListOK), nil

}

/*
GetDeviceDatasourceInstanceSDTHistory gets device instance SDT history
*/
func (a *Client) GetDeviceDatasourceInstanceSDTHistory(params *GetDeviceDatasourceInstanceSDTHistoryParams) (*GetDeviceDatasourceInstanceSDTHistoryOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceInstanceSDTHistoryParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceDatasourceInstanceSDTHistory",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}/historysdts",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceDatasourceInstanceSDTHistoryReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceDatasourceInstanceSDTHistoryOK), nil

}

/*
GetDeviceDatasourceList gets device datasource list
*/
func (a *Client) GetDeviceDatasourceList(params *GetDeviceDatasourceListParams) (*GetDeviceDatasourceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceDatasourceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupByID gets device group
*/
func (a *Client) GetDeviceGroupByID(params *GetDeviceGroupByIDParams) (*GetDeviceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupClusterAlertConfByID gets cluster alert configuration by id
*/
func (a *Client) GetDeviceGroupClusterAlertConfByID(params *GetDeviceGroupClusterAlertConfByIDParams) (*GetDeviceGroupClusterAlertConfByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupClusterAlertConfByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceGroupClusterAlertConfById",
		Method:             "GET",
		PathPattern:        "/device/groups/{deviceGroupId}/clusterAlertConf/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceGroupClusterAlertConfByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceGroupClusterAlertConfByIDOK), nil

}

/*
GetDeviceGroupClusterAlertConfList gets a list of cluster alert configurations for a device group
*/
func (a *Client) GetDeviceGroupClusterAlertConfList(params *GetDeviceGroupClusterAlertConfListParams) (*GetDeviceGroupClusterAlertConfListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupClusterAlertConfListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupDatasourceAlertSetting gets device group datasource alert setting
*/
func (a *Client) GetDeviceGroupDatasourceAlertSetting(params *GetDeviceGroupDatasourceAlertSettingParams) (*GetDeviceGroupDatasourceAlertSettingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupDatasourceAlertSettingParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceGroupDatasourceAlertSetting",
		Method:             "GET",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{dsId}/alertsettings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceGroupDatasourceAlertSettingReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceGroupDatasourceAlertSettingOK), nil

}

/*
GetDeviceGroupDatasourceByID gets device group datasource
*/
func (a *Client) GetDeviceGroupDatasourceByID(params *GetDeviceGroupDatasourceByIDParams) (*GetDeviceGroupDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceGroupDatasourceById",
		Method:             "GET",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceGroupDatasourceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceGroupDatasourceByIDOK), nil

}

/*
GetDeviceGroupDatasourceList gets device group datasource list
*/
func (a *Client) GetDeviceGroupDatasourceList(params *GetDeviceGroupDatasourceListParams) (*GetDeviceGroupDatasourceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupDatasourceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupList gets device group list
*/
func (a *Client) GetDeviceGroupList(params *GetDeviceGroupListParams) (*GetDeviceGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupPropertyByName gets device group property by name
*/
func (a *Client) GetDeviceGroupPropertyByName(params *GetDeviceGroupPropertyByNameParams) (*GetDeviceGroupPropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupPropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceGroupPropertyByName",
		Method:             "GET",
		PathPattern:        "/device/groups/{gid}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceGroupPropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceGroupPropertyByNameOK), nil

}

/*
GetDeviceGroupPropertyList gets device group properties
*/
func (a *Client) GetDeviceGroupPropertyList(params *GetDeviceGroupPropertyListParams) (*GetDeviceGroupPropertyListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupPropertyListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceGroupSDTList gets device group s d ts
*/
func (a *Client) GetDeviceGroupSDTList(params *GetDeviceGroupSDTListParams) (*GetDeviceGroupSDTListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceGroupSDTListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceInstanceGraphDataOnlyByInstanceID gets device instance data
*/
func (a *Client) GetDeviceInstanceGraphDataOnlyByInstanceID(params *GetDeviceInstanceGraphDataOnlyByInstanceIDParams) (*GetDeviceInstanceGraphDataOnlyByInstanceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceInstanceGraphDataOnlyByInstanceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDeviceInstanceGraphDataOnlyByInstanceId",
		Method:             "GET",
		PathPattern:        "/device/devicedatasourceinstances/{instanceId}/graphs/{graphId}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDeviceInstanceGraphDataOnlyByInstanceIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDeviceInstanceGraphDataOnlyByInstanceIDOK), nil

}

/*
GetDeviceInstanceList gets device instance list
*/
func (a *Client) GetDeviceInstanceList(params *GetDeviceInstanceListParams) (*GetDeviceInstanceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceInstanceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDeviceList gets device list
*/
func (a *Client) GetDeviceList(params *GetDeviceListParams) (*GetDeviceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDeviceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetDevicePropertyByName gets device property by name
*/
func (a *Client) GetDevicePropertyByName(params *GetDevicePropertyByNameParams) (*GetDevicePropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDevicePropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getDevicePropertyByName",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetDevicePropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetDevicePropertyByNameOK), nil

}

/*
GetDevicePropertyList gets device properties
*/
func (a *Client) GetDevicePropertyList(params *GetDevicePropertyListParams) (*GetDevicePropertyListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetDevicePropertyListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetEscalationChainByID gets escalation chain by id
*/
func (a *Client) GetEscalationChainByID(params *GetEscalationChainByIDParams) (*GetEscalationChainByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEscalationChainByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetEscalationChainList gets escalation chain list
*/
func (a *Client) GetEscalationChainList(params *GetEscalationChainListParams) (*GetEscalationChainListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEscalationChainListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetEventSourceList gets event source list
*/
func (a *Client) GetEventSourceList(params *GetEventSourceListParams) (*GetEventSourceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetEventSourceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetExternalAPIStats gets external api stats info
*/
func (a *Client) GetExternalAPIStats(params *GetExternalAPIStatsParams) (*GetExternalAPIStatsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetExternalAPIStatsParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetImmediateDeviceListByDeviceGroupID gets immediate devices under group
*/
func (a *Client) GetImmediateDeviceListByDeviceGroupID(params *GetImmediateDeviceListByDeviceGroupIDParams) (*GetImmediateDeviceListByDeviceGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetImmediateDeviceListByDeviceGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetImmediateWebsiteListByWebsiteGroupID gets a list of websites for a group
*/
func (a *Client) GetImmediateWebsiteListByWebsiteGroupID(params *GetImmediateWebsiteListByWebsiteGroupIDParams) (*GetImmediateWebsiteListByWebsiteGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetImmediateWebsiteListByWebsiteGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetMetricsUsage gets metrics usage
*/
func (a *Client) GetMetricsUsage(params *GetMetricsUsageParams) (*GetMetricsUsageOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetMetricsUsageParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetNetflowEndpointList gets netflow endpoint list
*/
func (a *Client) GetNetflowEndpointList(params *GetNetflowEndpointListParams) (*GetNetflowEndpointListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetflowEndpointListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetNetflowFlowList gets netflow flow list
*/
func (a *Client) GetNetflowFlowList(params *GetNetflowFlowListParams) (*GetNetflowFlowListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetflowFlowListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetNetflowPortList gets netflow port list
*/
func (a *Client) GetNetflowPortList(params *GetNetflowPortListParams) (*GetNetflowPortListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetflowPortListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetNetscanByID gets netscan by id
*/
func (a *Client) GetNetscanByID(params *GetNetscanByIDParams) (*GetNetscanByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetscanByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetNetscanList gets netscan list
*/
func (a *Client) GetNetscanList(params *GetNetscanListParams) (*GetNetscanListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetNetscanListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetOpsNoteByID gets opsnote by id
*/
func (a *Client) GetOpsNoteByID(params *GetOpsNoteByIDParams) (*GetOpsNoteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOpsNoteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetOpsNoteList gets opsnote list
*/
func (a *Client) GetOpsNoteList(params *GetOpsNoteListParams) (*GetOpsNoteListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetOpsNoteListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetRecipientGroupByID gets recipient group by id
*/
func (a *Client) GetRecipientGroupByID(params *GetRecipientGroupByIDParams) (*GetRecipientGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRecipientGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetRecipientGroupList gets recipient group list
*/
func (a *Client) GetRecipientGroupList(params *GetRecipientGroupListParams) (*GetRecipientGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRecipientGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetReportByID gets report by id
*/
func (a *Client) GetReportByID(params *GetReportByIDParams) (*GetReportByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReportByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetReportGroupByID gets report group by id
*/
func (a *Client) GetReportGroupByID(params *GetReportGroupByIDParams) (*GetReportGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReportGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetReportGroupList gets report group list
*/
func (a *Client) GetReportGroupList(params *GetReportGroupListParams) (*GetReportGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReportGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetReportList gets report list
*/
func (a *Client) GetReportList(params *GetReportListParams) (*GetReportListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetReportListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetRoleByID gets role by id
*/
func (a *Client) GetRoleByID(params *GetRoleByIDParams) (*GetRoleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRoleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetRoleList gets role list
*/
func (a *Client) GetRoleList(params *GetRoleListParams) (*GetRoleListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetRoleListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTByID gets SDT by id
*/
func (a *Client) GetSDTByID(params *GetSDTByIDParams) (*GetSDTByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTHistoryByDeviceDataSourceID gets SDT history for the device data source
*/
func (a *Client) GetSDTHistoryByDeviceDataSourceID(params *GetSDTHistoryByDeviceDataSourceIDParams) (*GetSDTHistoryByDeviceDataSourceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTHistoryByDeviceDataSourceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getSDTHistoryByDeviceDataSourceId",
		Method:             "GET",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{id}/historysdts",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetSDTHistoryByDeviceDataSourceIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetSDTHistoryByDeviceDataSourceIDOK), nil

}

/*
GetSDTHistoryByDeviceGroupID gets SDT history for the group
*/
func (a *Client) GetSDTHistoryByDeviceGroupID(params *GetSDTHistoryByDeviceGroupIDParams) (*GetSDTHistoryByDeviceGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTHistoryByDeviceGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTHistoryByDeviceID gets SDT history for the device
*/
func (a *Client) GetSDTHistoryByDeviceID(params *GetSDTHistoryByDeviceIDParams) (*GetSDTHistoryByDeviceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTHistoryByDeviceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTHistoryByWebsiteGroupID gets SDT history for the website group
*/
func (a *Client) GetSDTHistoryByWebsiteGroupID(params *GetSDTHistoryByWebsiteGroupIDParams) (*GetSDTHistoryByWebsiteGroupIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTHistoryByWebsiteGroupIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTHistoryByWebsiteID gets SDT history for the website
*/
func (a *Client) GetSDTHistoryByWebsiteID(params *GetSDTHistoryByWebsiteIDParams) (*GetSDTHistoryByWebsiteIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTHistoryByWebsiteIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSDTList gets SDT list
*/
func (a *Client) GetSDTList(params *GetSDTListParams) (*GetSDTListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSDTListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetSiteMonitorCheckPointList gets website checkpoint list
*/
func (a *Client) GetSiteMonitorCheckPointList(params *GetSiteMonitorCheckPointListParams) (*GetSiteMonitorCheckPointListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetSiteMonitorCheckPointListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetTopTalkersGraph gets top talkers graph
*/
func (a *Client) GetTopTalkersGraph(params *GetTopTalkersGraphParams) (*GetTopTalkersGraphOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetTopTalkersGraphParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetUnmonitoredDeviceList gets unmonitored device list
*/
func (a *Client) GetUnmonitoredDeviceList(params *GetUnmonitoredDeviceListParams) (*GetUnmonitoredDeviceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUnmonitoredDeviceListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetUpdateReasonListByDataSourceID gets update history for a datasource
*/
func (a *Client) GetUpdateReasonListByDataSourceID(params *GetUpdateReasonListByDataSourceIDParams) (*GetUpdateReasonListByDataSourceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetUpdateReasonListByDataSourceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteAlertListByWebsiteID gets alerts for a website
*/
func (a *Client) GetWebsiteAlertListByWebsiteID(params *GetWebsiteAlertListByWebsiteIDParams) (*GetWebsiteAlertListByWebsiteIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteAlertListByWebsiteIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteByID gets website by id
*/
func (a *Client) GetWebsiteByID(params *GetWebsiteByIDParams) (*GetWebsiteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteCheckpointDataByID gets data for a website checkpoint
*/
func (a *Client) GetWebsiteCheckpointDataByID(params *GetWebsiteCheckpointDataByIDParams) (*GetWebsiteCheckpointDataByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteCheckpointDataByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getWebsiteCheckpointDataById",
		Method:             "GET",
		PathPattern:        "/website/websites/{srvId}/checkpoints/{checkId}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetWebsiteCheckpointDataByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetWebsiteCheckpointDataByIDOK), nil

}

/*
GetWebsiteDataByGraphName gets website data by graph name
*/
func (a *Client) GetWebsiteDataByGraphName(params *GetWebsiteDataByGraphNameParams) (*GetWebsiteDataByGraphNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteDataByGraphNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getWebsiteDataByGraphName",
		Method:             "GET",
		PathPattern:        "/website/websites/{id}/graphs/{graphName}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetWebsiteDataByGraphNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetWebsiteDataByGraphNameOK), nil

}

/*
GetWebsiteGraphData gets website graph data
*/
func (a *Client) GetWebsiteGraphData(params *GetWebsiteGraphDataParams) (*GetWebsiteGraphDataOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteGraphDataParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "getWebsiteGraphData",
		Method:             "GET",
		PathPattern:        "/website/websites/{websiteId}/checkpoints/{checkpointId}/graphs/{graphName}/data",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &GetWebsiteGraphDataReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*GetWebsiteGraphDataOK), nil

}

/*
GetWebsiteGroupByID gets website group
*/
func (a *Client) GetWebsiteGroupByID(params *GetWebsiteGroupByIDParams) (*GetWebsiteGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteGroupList gets website group list
*/
func (a *Client) GetWebsiteGroupList(params *GetWebsiteGroupListParams) (*GetWebsiteGroupListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteGroupListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteList gets website list
*/
func (a *Client) GetWebsiteList(params *GetWebsiteListParams) (*GetWebsiteListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsitePropertyListByWebsiteID gets a list of properties for a website
*/
func (a *Client) GetWebsitePropertyListByWebsiteID(params *GetWebsitePropertyListByWebsiteIDParams) (*GetWebsitePropertyListByWebsiteIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsitePropertyListByWebsiteIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWebsiteSDTListByWebsiteID gets a list of s d ts for a website
*/
func (a *Client) GetWebsiteSDTListByWebsiteID(params *GetWebsiteSDTListByWebsiteIDParams) (*GetWebsiteSDTListByWebsiteIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWebsiteSDTListByWebsiteIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWidgetByID gets widget by id
*/
func (a *Client) GetWidgetByID(params *GetWidgetByIDParams) (*GetWidgetByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWidgetByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWidgetDataByID gets widget data
*/
func (a *Client) GetWidgetDataByID(params *GetWidgetDataByIDParams) (*GetWidgetDataByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWidgetDataByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWidgetList gets widget list
*/
func (a *Client) GetWidgetList(params *GetWidgetListParams) (*GetWidgetListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWidgetListParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
GetWidgetListByDashboardID gets widget list by dashboard Id
*/
func (a *Client) GetWidgetListByDashboardID(params *GetWidgetListByDashboardIDParams) (*GetWidgetListByDashboardIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewGetWidgetListByDashboardIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
ImportBatchJob imports batch job via xml
*/
func (a *Client) ImportBatchJob(params *ImportBatchJobParams) (*ImportBatchJobOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewImportBatchJobParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "importBatchJob",
		Method:             "POST",
		PathPattern:        "/setting/batchjobs/importxml",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"multipart/form-data"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ImportBatchJobReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportBatchJobOK), nil

}

/*
ImportConfigSource imports config source via xml
*/
func (a *Client) ImportConfigSource(params *ImportConfigSourceParams) (*ImportConfigSourceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewImportConfigSourceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "importConfigSource",
		Method:             "POST",
		PathPattern:        "/setting/configsources/importxml",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"multipart/form-data"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ImportConfigSourceReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportConfigSourceOK), nil

}

/*
ImportDNSMapping imports DNS mapping via c s v
*/
func (a *Client) ImportDNSMapping(params *ImportDNSMappingParams) (*ImportDNSMappingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewImportDNSMappingParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "importDNSMapping",
		Method:             "POST",
		PathPattern:        "/setting/dnsmappings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"multipart/form-data"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ImportDNSMappingReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportDNSMappingOK), nil

}

/*
ImportDataSource imports datasource via xml
*/
func (a *Client) ImportDataSource(params *ImportDataSourceParams) (*ImportDataSourceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewImportDataSourceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "importDataSource",
		Method:             "POST",
		PathPattern:        "/setting/datasources/importxml",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"multipart/form-data"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ImportDataSourceReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportDataSourceOK), nil

}

/*
ImportEventSource imports eventsource via xml
*/
func (a *Client) ImportEventSource(params *ImportEventSourceParams) (*ImportEventSourceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewImportEventSourceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "importEventSource",
		Method:             "POST",
		PathPattern:        "/setting/eventsources/importxml",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"multipart/form-data"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ImportEventSourceReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ImportEventSourceOK), nil

}

/*
PatchAdminByID updates user
*/
func (a *Client) PatchAdminByID(params *PatchAdminByIDParams) (*PatchAdminByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchAdminByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchAdminById",
		Method:             "PATCH",
		PathPattern:        "/setting/admins/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchAdminByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchAdminByIDOK), nil

}

/*
PatchAlertRuleByID updates alert rule
*/
func (a *Client) PatchAlertRuleByID(params *PatchAlertRuleByIDParams) (*PatchAlertRuleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchAlertRuleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchAlertRuleById",
		Method:             "PATCH",
		PathPattern:        "/setting/alert/rules/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchAlertRuleByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchAlertRuleByIDOK), nil

}

/*
PatchAPITokenByAdminID updates api tokens for a user
*/
func (a *Client) PatchAPITokenByAdminID(params *PatchAPITokenByAdminIDParams) (*PatchAPITokenByAdminIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchAPITokenByAdminIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchApiTokenByAdminId",
		Method:             "PATCH",
		PathPattern:        "/setting/admins/{adminId}/apitokens/{apitokenId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchAPITokenByAdminIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchAPITokenByAdminIDOK), nil

}

/*
PatchAppliesToFunction updates applies to function
*/
func (a *Client) PatchAppliesToFunction(params *PatchAppliesToFunctionParams) (*PatchAppliesToFunctionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchAppliesToFunctionParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchAppliesToFunction",
		Method:             "PATCH",
		PathPattern:        "/setting/functions/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchAppliesToFunctionReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchAppliesToFunctionOK), nil

}

/*
PatchCollectorByID updates collector
*/
func (a *Client) PatchCollectorByID(params *PatchCollectorByIDParams) (*PatchCollectorByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchCollectorByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchCollectorById",
		Method:             "PATCH",
		PathPattern:        "/setting/collector/collectors/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchCollectorByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchCollectorByIDOK), nil

}

/*
PatchCollectorGroupByID updates collector group
*/
func (a *Client) PatchCollectorGroupByID(params *PatchCollectorGroupByIDParams) (*PatchCollectorGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchCollectorGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchCollectorGroupById",
		Method:             "PATCH",
		PathPattern:        "/setting/collector/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchCollectorGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchCollectorGroupByIDOK), nil

}

/*
PatchDashboardByID updates dashboard

The template field works only for the POST API
*/
func (a *Client) PatchDashboardByID(params *PatchDashboardByIDParams) (*PatchDashboardByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDashboardByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDashboardById",
		Method:             "PATCH",
		PathPattern:        "/dashboard/dashboards/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDashboardByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDashboardByIDOK), nil

}

/*
PatchDashboardGroupByID updates dashboard group

The template field works only for the POST API
*/
func (a *Client) PatchDashboardGroupByID(params *PatchDashboardGroupByIDParams) (*PatchDashboardGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDashboardGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDashboardGroupById",
		Method:             "PATCH",
		PathPattern:        "/dashboard/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDashboardGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDashboardGroupByIDOK), nil

}

/*
PatchDevice updates a device
*/
func (a *Client) PatchDevice(params *PatchDeviceParams) (*PatchDeviceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDevice",
		Method:             "PATCH",
		PathPattern:        "/device/devices/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceOK), nil

}

/*
PatchDeviceDatasourceInstanceAlertSettingByID updates device instance alert setting
*/
func (a *Client) PatchDeviceDatasourceInstanceAlertSettingByID(params *PatchDeviceDatasourceInstanceAlertSettingByIDParams) (*PatchDeviceDatasourceInstanceAlertSettingByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceDatasourceInstanceAlertSettingByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceDatasourceInstanceAlertSettingById",
		Method:             "PATCH",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/alertsettings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceDatasourceInstanceAlertSettingByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceDatasourceInstanceAlertSettingByIDOK), nil

}

/*
PatchDeviceDatasourceInstanceByID updates device instance
*/
func (a *Client) PatchDeviceDatasourceInstanceByID(params *PatchDeviceDatasourceInstanceByIDParams) (*PatchDeviceDatasourceInstanceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceDatasourceInstanceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceDatasourceInstanceById",
		Method:             "PATCH",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceDatasourceInstanceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceDatasourceInstanceByIDOK), nil

}

/*
PatchDeviceDatasourceInstanceGroupByID updates device datasource instance group
*/
func (a *Client) PatchDeviceDatasourceInstanceGroupByID(params *PatchDeviceDatasourceInstanceGroupByIDParams) (*PatchDeviceDatasourceInstanceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceDatasourceInstanceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceDatasourceInstanceGroupById",
		Method:             "PATCH",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceDatasourceInstanceGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceDatasourceInstanceGroupByIDOK), nil

}

/*
PatchDeviceGroupByID updates device group
*/
func (a *Client) PatchDeviceGroupByID(params *PatchDeviceGroupByIDParams) (*PatchDeviceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceGroupById",
		Method:             "PATCH",
		PathPattern:        "/device/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceGroupByIDOK), nil

}

/*
PatchDeviceGroupClusterAlertConfByID updates cluster alert configuration
*/
func (a *Client) PatchDeviceGroupClusterAlertConfByID(params *PatchDeviceGroupClusterAlertConfByIDParams) (*PatchDeviceGroupClusterAlertConfByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceGroupClusterAlertConfByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceGroupClusterAlertConfById",
		Method:             "PATCH",
		PathPattern:        "/device/groups/{deviceGroupId}/clusterAlertConf/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceGroupClusterAlertConfByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceGroupClusterAlertConfByIDOK), nil

}

/*
PatchDeviceGroupDatasourceAlertSetting updates device group datasource alert setting
*/
func (a *Client) PatchDeviceGroupDatasourceAlertSetting(params *PatchDeviceGroupDatasourceAlertSettingParams) (*PatchDeviceGroupDatasourceAlertSettingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceGroupDatasourceAlertSettingParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceGroupDatasourceAlertSetting",
		Method:             "PATCH",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{dsId}/alertsettings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceGroupDatasourceAlertSettingReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceGroupDatasourceAlertSettingOK), nil

}

/*
PatchDeviceGroupDatasourceByID updates device group datasource
*/
func (a *Client) PatchDeviceGroupDatasourceByID(params *PatchDeviceGroupDatasourceByIDParams) (*PatchDeviceGroupDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceGroupDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceGroupDatasourceById",
		Method:             "PATCH",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceGroupDatasourceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceGroupDatasourceByIDOK), nil

}

/*
PatchDeviceGroupPropertyByName updates device group property
*/
func (a *Client) PatchDeviceGroupPropertyByName(params *PatchDeviceGroupPropertyByNameParams) (*PatchDeviceGroupPropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDeviceGroupPropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDeviceGroupPropertyByName",
		Method:             "PATCH",
		PathPattern:        "/device/groups/{gid}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDeviceGroupPropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDeviceGroupPropertyByNameOK), nil

}

/*
PatchDevicePropertyByName updates device property
*/
func (a *Client) PatchDevicePropertyByName(params *PatchDevicePropertyByNameParams) (*PatchDevicePropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchDevicePropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchDevicePropertyByName",
		Method:             "PATCH",
		PathPattern:        "/device/devices/{deviceId}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchDevicePropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchDevicePropertyByNameOK), nil

}

/*
PatchEscalationChainByID updates escalation chain
*/
func (a *Client) PatchEscalationChainByID(params *PatchEscalationChainByIDParams) (*PatchEscalationChainByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchEscalationChainByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchEscalationChainById",
		Method:             "PATCH",
		PathPattern:        "/setting/alert/chains/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchEscalationChainByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchEscalationChainByIDOK), nil

}

/*
PatchNetscan updates a netscan
*/
func (a *Client) PatchNetscan(params *PatchNetscanParams) (*PatchNetscanOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchNetscanParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchNetscan",
		Method:             "PATCH",
		PathPattern:        "/setting/netscans/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchNetscanReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchNetscanOK), nil

}

/*
PatchOpsNoteByID updates opsnote
*/
func (a *Client) PatchOpsNoteByID(params *PatchOpsNoteByIDParams) (*PatchOpsNoteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchOpsNoteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchOpsNoteById",
		Method:             "PATCH",
		PathPattern:        "/setting/opsnotes/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchOpsNoteByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchOpsNoteByIDOK), nil

}

/*
PatchRecipientGroupByID updates recipient group
*/
func (a *Client) PatchRecipientGroupByID(params *PatchRecipientGroupByIDParams) (*PatchRecipientGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchRecipientGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchRecipientGroupById",
		Method:             "PATCH",
		PathPattern:        "/setting/recipientgroups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchRecipientGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchRecipientGroupByIDOK), nil

}

/*
PatchReportByID updates report
*/
func (a *Client) PatchReportByID(params *PatchReportByIDParams) (*PatchReportByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchReportByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchReportById",
		Method:             "PATCH",
		PathPattern:        "/report/reports/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchReportByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchReportByIDOK), nil

}

/*
PatchReportGroupByID updates report group
*/
func (a *Client) PatchReportGroupByID(params *PatchReportGroupByIDParams) (*PatchReportGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchReportGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchReportGroupById",
		Method:             "PATCH",
		PathPattern:        "/report/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchReportGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchReportGroupByIDOK), nil

}

/*
PatchRoleByID updates role
*/
func (a *Client) PatchRoleByID(params *PatchRoleByIDParams) (*PatchRoleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchRoleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchRoleById",
		Method:             "PATCH",
		PathPattern:        "/setting/roles/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchRoleByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchRoleByIDOK), nil

}

/*
PatchSDTByID updates SDT
*/
func (a *Client) PatchSDTByID(params *PatchSDTByIDParams) (*PatchSDTByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchSDTByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchSDTById",
		Method:             "PATCH",
		PathPattern:        "/sdt/sdts/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchSDTByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchSDTByIDOK), nil

}

/*
PatchWebsiteByID updates website
*/
func (a *Client) PatchWebsiteByID(params *PatchWebsiteByIDParams) (*PatchWebsiteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchWebsiteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchWebsiteById",
		Method:             "PATCH",
		PathPattern:        "/website/websites/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchWebsiteByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchWebsiteByIDOK), nil

}

/*
PatchWebsiteGroupByID updates website group
*/
func (a *Client) PatchWebsiteGroupByID(params *PatchWebsiteGroupByIDParams) (*PatchWebsiteGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchWebsiteGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchWebsiteGroupById",
		Method:             "PATCH",
		PathPattern:        "/website/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchWebsiteGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchWebsiteGroupByIDOK), nil

}

/*
PatchWidgetByID updates widget
*/
func (a *Client) PatchWidgetByID(params *PatchWidgetByIDParams) (*PatchWidgetByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewPatchWidgetByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "patchWidgetById",
		Method:             "PATCH",
		PathPattern:        "/dashboard/widgets/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &PatchWidgetByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*PatchWidgetByIDOK), nil

}

/*
ScheduleAutoDiscoveryByDeviceID schedules active discovery for a device
*/
func (a *Client) ScheduleAutoDiscoveryByDeviceID(params *ScheduleAutoDiscoveryByDeviceIDParams) (*ScheduleAutoDiscoveryByDeviceIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewScheduleAutoDiscoveryByDeviceIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "scheduleAutoDiscoveryByDeviceId",
		Method:             "POST",
		PathPattern:        "/device/devices/{id}/scheduleAutoDiscovery",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &ScheduleAutoDiscoveryByDeviceIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*ScheduleAutoDiscoveryByDeviceIDOK), nil

}

/*
UpdateAdminByID updates user
*/
func (a *Client) UpdateAdminByID(params *UpdateAdminByIDParams) (*UpdateAdminByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateAdminByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateAlertRuleByID updates alert rule
*/
func (a *Client) UpdateAlertRuleByID(params *UpdateAlertRuleByIDParams) (*UpdateAlertRuleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateAlertRuleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateAlertRuleById",
		Method:             "PUT",
		PathPattern:        "/setting/alert/rules/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateAlertRuleByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateAlertRuleByIDOK), nil

}

/*
UpdateAPITokenByAdminID updates api tokens for a user
*/
func (a *Client) UpdateAPITokenByAdminID(params *UpdateAPITokenByAdminIDParams) (*UpdateAPITokenByAdminIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateAPITokenByAdminIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateApiTokenByAdminId",
		Method:             "PUT",
		PathPattern:        "/setting/admins/{adminId}/apitokens/{apitokenId}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateAPITokenByAdminIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateAPITokenByAdminIDOK), nil

}

/*
UpdateAppliesToFunction updates applies to function
*/
func (a *Client) UpdateAppliesToFunction(params *UpdateAppliesToFunctionParams) (*UpdateAppliesToFunctionOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateAppliesToFunctionParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateCollectorByID updates collector
*/
func (a *Client) UpdateCollectorByID(params *UpdateCollectorByIDParams) (*UpdateCollectorByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCollectorByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateCollectorById",
		Method:             "PUT",
		PathPattern:        "/setting/collector/collectors/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateCollectorByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateCollectorByIDOK), nil

}

/*
UpdateCollectorGroupByID updates collector group
*/
func (a *Client) UpdateCollectorGroupByID(params *UpdateCollectorGroupByIDParams) (*UpdateCollectorGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateCollectorGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateCollectorGroupById",
		Method:             "PUT",
		PathPattern:        "/setting/collector/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateCollectorGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateCollectorGroupByIDOK), nil

}

/*
UpdateDashboardByID updates dashboard

The template field works only for the POST API
*/
func (a *Client) UpdateDashboardByID(params *UpdateDashboardByIDParams) (*UpdateDashboardByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDashboardByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateDashboardGroupByID updates dashboard group

The template field works only for the POST API
*/
func (a *Client) UpdateDashboardGroupByID(params *UpdateDashboardGroupByIDParams) (*UpdateDashboardGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDashboardGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateDevice updates a device
*/
func (a *Client) UpdateDevice(params *UpdateDeviceParams) (*UpdateDeviceOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateDeviceDatasourceInstanceAlertSettingByID updates device instance alert setting
*/
func (a *Client) UpdateDeviceDatasourceInstanceAlertSettingByID(params *UpdateDeviceDatasourceInstanceAlertSettingByIDParams) (*UpdateDeviceDatasourceInstanceAlertSettingByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceDatasourceInstanceAlertSettingByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceDatasourceInstanceAlertSettingById",
		Method:             "PUT",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{instanceId}/alertsettings/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceDatasourceInstanceAlertSettingByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceDatasourceInstanceAlertSettingByIDOK), nil

}

/*
UpdateDeviceDatasourceInstanceByID updates device instance
*/
func (a *Client) UpdateDeviceDatasourceInstanceByID(params *UpdateDeviceDatasourceInstanceByIDParams) (*UpdateDeviceDatasourceInstanceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceDatasourceInstanceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceDatasourceInstanceById",
		Method:             "PUT",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{hdsId}/instances/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceDatasourceInstanceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceDatasourceInstanceByIDOK), nil

}

/*
UpdateDeviceDatasourceInstanceGroupByID updates device datasource instance group
*/
func (a *Client) UpdateDeviceDatasourceInstanceGroupByID(params *UpdateDeviceDatasourceInstanceGroupByIDParams) (*UpdateDeviceDatasourceInstanceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceDatasourceInstanceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceDatasourceInstanceGroupById",
		Method:             "PUT",
		PathPattern:        "/device/devices/{deviceId}/devicedatasources/{deviceDsId}/groups/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceDatasourceInstanceGroupByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceDatasourceInstanceGroupByIDOK), nil

}

/*
UpdateDeviceGroupByID updates device group
*/
func (a *Client) UpdateDeviceGroupByID(params *UpdateDeviceGroupByIDParams) (*UpdateDeviceGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateDeviceGroupClusterAlertConfByID updates cluster alert configuration
*/
func (a *Client) UpdateDeviceGroupClusterAlertConfByID(params *UpdateDeviceGroupClusterAlertConfByIDParams) (*UpdateDeviceGroupClusterAlertConfByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceGroupClusterAlertConfByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceGroupClusterAlertConfById",
		Method:             "PUT",
		PathPattern:        "/device/groups/{deviceGroupId}/clusterAlertConf/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceGroupClusterAlertConfByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceGroupClusterAlertConfByIDOK), nil

}

/*
UpdateDeviceGroupDatasourceAlertSetting updates device group datasource alert setting
*/
func (a *Client) UpdateDeviceGroupDatasourceAlertSetting(params *UpdateDeviceGroupDatasourceAlertSettingParams) (*UpdateDeviceGroupDatasourceAlertSettingOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceGroupDatasourceAlertSettingParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceGroupDatasourceAlertSetting",
		Method:             "PUT",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{dsId}/alertsettings",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceGroupDatasourceAlertSettingReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceGroupDatasourceAlertSettingOK), nil

}

/*
UpdateDeviceGroupDatasourceByID updates device group datasource
*/
func (a *Client) UpdateDeviceGroupDatasourceByID(params *UpdateDeviceGroupDatasourceByIDParams) (*UpdateDeviceGroupDatasourceByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceGroupDatasourceByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceGroupDatasourceById",
		Method:             "PUT",
		PathPattern:        "/device/groups/{deviceGroupId}/datasources/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceGroupDatasourceByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceGroupDatasourceByIDOK), nil

}

/*
UpdateDeviceGroupPropertyByName updates device group property
*/
func (a *Client) UpdateDeviceGroupPropertyByName(params *UpdateDeviceGroupPropertyByNameParams) (*UpdateDeviceGroupPropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDeviceGroupPropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDeviceGroupPropertyByName",
		Method:             "PUT",
		PathPattern:        "/device/groups/{gid}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDeviceGroupPropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDeviceGroupPropertyByNameOK), nil

}

/*
UpdateDevicePropertyByName updates device property
*/
func (a *Client) UpdateDevicePropertyByName(params *UpdateDevicePropertyByNameParams) (*UpdateDevicePropertyByNameOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateDevicePropertyByNameParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateDevicePropertyByName",
		Method:             "PUT",
		PathPattern:        "/device/devices/{deviceId}/properties/{name}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateDevicePropertyByNameReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateDevicePropertyByNameOK), nil

}

/*
UpdateEscalationChainByID updates escalation chain
*/
func (a *Client) UpdateEscalationChainByID(params *UpdateEscalationChainByIDParams) (*UpdateEscalationChainByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateEscalationChainByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "updateEscalationChainById",
		Method:             "PUT",
		PathPattern:        "/setting/alert/chains/{id}",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"https"},
		Params:             params,
		Reader:             &UpdateEscalationChainByIDReader{formats: a.formats},
		AuthInfo:           a.authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*UpdateEscalationChainByIDOK), nil

}

/*
UpdateNetscan updates a netscan
*/
func (a *Client) UpdateNetscan(params *UpdateNetscanParams) (*UpdateNetscanOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateNetscanParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateOpsNoteByID updates opsnote
*/
func (a *Client) UpdateOpsNoteByID(params *UpdateOpsNoteByIDParams) (*UpdateOpsNoteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateOpsNoteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateRecipientGroupByID updates recipient group
*/
func (a *Client) UpdateRecipientGroupByID(params *UpdateRecipientGroupByIDParams) (*UpdateRecipientGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRecipientGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateReportByID updates report
*/
func (a *Client) UpdateReportByID(params *UpdateReportByIDParams) (*UpdateReportByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateReportByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateReportGroupByID updates report group
*/
func (a *Client) UpdateReportGroupByID(params *UpdateReportGroupByIDParams) (*UpdateReportGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateReportGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateRoleByID updates role
*/
func (a *Client) UpdateRoleByID(params *UpdateRoleByIDParams) (*UpdateRoleByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateRoleByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateSDTByID updates SDT
*/
func (a *Client) UpdateSDTByID(params *UpdateSDTByIDParams) (*UpdateSDTByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateSDTByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateWebsiteByID updates website
*/
func (a *Client) UpdateWebsiteByID(params *UpdateWebsiteByIDParams) (*UpdateWebsiteByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateWebsiteByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateWebsiteGroupByID updates website group
*/
func (a *Client) UpdateWebsiteGroupByID(params *UpdateWebsiteGroupByIDParams) (*UpdateWebsiteGroupByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateWebsiteGroupByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

/*
UpdateWidgetByID updates widget
*/
func (a *Client) UpdateWidgetByID(params *UpdateWidgetByIDParams) (*UpdateWidgetByIDOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewUpdateWidgetByIDParams()
	}
	reflect.ValueOf(params).MethodByName("SetUserAgent").Call([]reflect.Value{reflect.ValueOf(a.userAgent)})

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

}

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

// SetUserAgent changes the userAgent on the client
func (a *Client) SetUserAgent(userAgent *string) {
	a.userAgent = userAgent
}
