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

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

package dcim

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

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

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

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

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

/*
DcimChoicesList dcim choices list API
*/
func (a *Client) DcimChoicesList(params *DcimChoicesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimChoicesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimChoicesListParams()
	}

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

}

/*
DcimChoicesRead dcim choices read API
*/
func (a *Client) DcimChoicesRead(params *DcimChoicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimChoicesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimChoicesReadParams()
	}

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

}

/*
DcimConnectedDeviceList This endpoint allows a user to determine what device (if any) is connected to a given peer device and peer
interface. This is useful in a situation where a device boots with no configuration, but can detect its neighbors
via a protocol such as LLDP. Two query parameters must be included in the request:

* `peer-device`: The name of the peer device
* `peer-interface`: The name of the peer interface
*/
func (a *Client) DcimConnectedDeviceList(params *DcimConnectedDeviceListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConnectedDeviceListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConnectedDeviceListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_connected-device_list",
		Method:             "GET",
		PathPattern:        "/dcim/connected-device/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConnectedDeviceListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConnectedDeviceListOK), nil

}

/*
DcimConsoleConnectionsList dcim console connections list API
*/
func (a *Client) DcimConsoleConnectionsList(params *DcimConsoleConnectionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleConnectionsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleConnectionsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-connections_list",
		Method:             "GET",
		PathPattern:        "/dcim/console-connections/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleConnectionsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleConnectionsListOK), nil

}

/*
DcimConsolePortTemplatesCreate dcim console port templates create API
*/
func (a *Client) DcimConsolePortTemplatesCreate(params *DcimConsolePortTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/console-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesCreateCreated), nil

}

/*
DcimConsolePortTemplatesDelete dcim console port templates delete API
*/
func (a *Client) DcimConsolePortTemplatesDelete(params *DcimConsolePortTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/console-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesDeleteNoContent), nil

}

/*
DcimConsolePortTemplatesList dcim console port templates list API
*/
func (a *Client) DcimConsolePortTemplatesList(params *DcimConsolePortTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/console-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesListOK), nil

}

/*
DcimConsolePortTemplatesPartialUpdate dcim console port templates partial update API
*/
func (a *Client) DcimConsolePortTemplatesPartialUpdate(params *DcimConsolePortTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/console-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesPartialUpdateOK), nil

}

/*
DcimConsolePortTemplatesRead dcim console port templates read API
*/
func (a *Client) DcimConsolePortTemplatesRead(params *DcimConsolePortTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/console-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesReadOK), nil

}

/*
DcimConsolePortTemplatesUpdate dcim console port templates update API
*/
func (a *Client) DcimConsolePortTemplatesUpdate(params *DcimConsolePortTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-port-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/console-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortTemplatesUpdateOK), nil

}

/*
DcimConsolePortsCreate dcim console ports create API
*/
func (a *Client) DcimConsolePortsCreate(params *DcimConsolePortsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_create",
		Method:             "POST",
		PathPattern:        "/dcim/console-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsCreateCreated), nil

}

/*
DcimConsolePortsDelete dcim console ports delete API
*/
func (a *Client) DcimConsolePortsDelete(params *DcimConsolePortsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/console-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsDeleteNoContent), nil

}

/*
DcimConsolePortsList dcim console ports list API
*/
func (a *Client) DcimConsolePortsList(params *DcimConsolePortsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_list",
		Method:             "GET",
		PathPattern:        "/dcim/console-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsListOK), nil

}

/*
DcimConsolePortsPartialUpdate dcim console ports partial update API
*/
func (a *Client) DcimConsolePortsPartialUpdate(params *DcimConsolePortsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/console-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsPartialUpdateOK), nil

}

/*
DcimConsolePortsRead dcim console ports read API
*/
func (a *Client) DcimConsolePortsRead(params *DcimConsolePortsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_read",
		Method:             "GET",
		PathPattern:        "/dcim/console-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsReadOK), nil

}

/*
DcimConsolePortsUpdate dcim console ports update API
*/
func (a *Client) DcimConsolePortsUpdate(params *DcimConsolePortsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsolePortsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-ports_update",
		Method:             "PUT",
		PathPattern:        "/dcim/console-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsolePortsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsolePortsUpdateOK), nil

}

/*
DcimConsoleServerPortTemplatesCreate dcim console server port templates create API
*/
func (a *Client) DcimConsoleServerPortTemplatesCreate(params *DcimConsoleServerPortTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/console-server-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesCreateCreated), nil

}

/*
DcimConsoleServerPortTemplatesDelete dcim console server port templates delete API
*/
func (a *Client) DcimConsoleServerPortTemplatesDelete(params *DcimConsoleServerPortTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/console-server-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesDeleteNoContent), nil

}

/*
DcimConsoleServerPortTemplatesList dcim console server port templates list API
*/
func (a *Client) DcimConsoleServerPortTemplatesList(params *DcimConsoleServerPortTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/console-server-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesListOK), nil

}

/*
DcimConsoleServerPortTemplatesPartialUpdate dcim console server port templates partial update API
*/
func (a *Client) DcimConsoleServerPortTemplatesPartialUpdate(params *DcimConsoleServerPortTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/console-server-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesPartialUpdateOK), nil

}

/*
DcimConsoleServerPortTemplatesRead dcim console server port templates read API
*/
func (a *Client) DcimConsoleServerPortTemplatesRead(params *DcimConsoleServerPortTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/console-server-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesReadOK), nil

}

/*
DcimConsoleServerPortTemplatesUpdate dcim console server port templates update API
*/
func (a *Client) DcimConsoleServerPortTemplatesUpdate(params *DcimConsoleServerPortTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-port-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/console-server-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortTemplatesUpdateOK), nil

}

/*
DcimConsoleServerPortsCreate dcim console server ports create API
*/
func (a *Client) DcimConsoleServerPortsCreate(params *DcimConsoleServerPortsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_create",
		Method:             "POST",
		PathPattern:        "/dcim/console-server-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsCreateCreated), nil

}

/*
DcimConsoleServerPortsDelete dcim console server ports delete API
*/
func (a *Client) DcimConsoleServerPortsDelete(params *DcimConsoleServerPortsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/console-server-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsDeleteNoContent), nil

}

/*
DcimConsoleServerPortsList dcim console server ports list API
*/
func (a *Client) DcimConsoleServerPortsList(params *DcimConsoleServerPortsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_list",
		Method:             "GET",
		PathPattern:        "/dcim/console-server-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsListOK), nil

}

/*
DcimConsoleServerPortsPartialUpdate dcim console server ports partial update API
*/
func (a *Client) DcimConsoleServerPortsPartialUpdate(params *DcimConsoleServerPortsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/console-server-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsPartialUpdateOK), nil

}

/*
DcimConsoleServerPortsRead dcim console server ports read API
*/
func (a *Client) DcimConsoleServerPortsRead(params *DcimConsoleServerPortsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_read",
		Method:             "GET",
		PathPattern:        "/dcim/console-server-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsReadOK), nil

}

/*
DcimConsoleServerPortsUpdate dcim console server ports update API
*/
func (a *Client) DcimConsoleServerPortsUpdate(params *DcimConsoleServerPortsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsoleServerPortsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimConsoleServerPortsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_console-server-ports_update",
		Method:             "PUT",
		PathPattern:        "/dcim/console-server-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimConsoleServerPortsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimConsoleServerPortsUpdateOK), nil

}

/*
DcimDeviceBayTemplatesCreate dcim device bay templates create API
*/
func (a *Client) DcimDeviceBayTemplatesCreate(params *DcimDeviceBayTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/device-bay-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesCreateCreated), nil

}

/*
DcimDeviceBayTemplatesDelete dcim device bay templates delete API
*/
func (a *Client) DcimDeviceBayTemplatesDelete(params *DcimDeviceBayTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/device-bay-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesDeleteNoContent), nil

}

/*
DcimDeviceBayTemplatesList dcim device bay templates list API
*/
func (a *Client) DcimDeviceBayTemplatesList(params *DcimDeviceBayTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/device-bay-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesListOK), nil

}

/*
DcimDeviceBayTemplatesPartialUpdate dcim device bay templates partial update API
*/
func (a *Client) DcimDeviceBayTemplatesPartialUpdate(params *DcimDeviceBayTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/device-bay-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesPartialUpdateOK), nil

}

/*
DcimDeviceBayTemplatesRead dcim device bay templates read API
*/
func (a *Client) DcimDeviceBayTemplatesRead(params *DcimDeviceBayTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/device-bay-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesReadOK), nil

}

/*
DcimDeviceBayTemplatesUpdate dcim device bay templates update API
*/
func (a *Client) DcimDeviceBayTemplatesUpdate(params *DcimDeviceBayTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBayTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBayTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bay-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/device-bay-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBayTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBayTemplatesUpdateOK), nil

}

/*
DcimDeviceBaysCreate dcim device bays create API
*/
func (a *Client) DcimDeviceBaysCreate(params *DcimDeviceBaysCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_create",
		Method:             "POST",
		PathPattern:        "/dcim/device-bays/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysCreateCreated), nil

}

/*
DcimDeviceBaysDelete dcim device bays delete API
*/
func (a *Client) DcimDeviceBaysDelete(params *DcimDeviceBaysDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/device-bays/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysDeleteNoContent), nil

}

/*
DcimDeviceBaysList dcim device bays list API
*/
func (a *Client) DcimDeviceBaysList(params *DcimDeviceBaysListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_list",
		Method:             "GET",
		PathPattern:        "/dcim/device-bays/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysListOK), nil

}

/*
DcimDeviceBaysPartialUpdate dcim device bays partial update API
*/
func (a *Client) DcimDeviceBaysPartialUpdate(params *DcimDeviceBaysPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/device-bays/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysPartialUpdateOK), nil

}

/*
DcimDeviceBaysRead dcim device bays read API
*/
func (a *Client) DcimDeviceBaysRead(params *DcimDeviceBaysReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_read",
		Method:             "GET",
		PathPattern:        "/dcim/device-bays/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysReadOK), nil

}

/*
DcimDeviceBaysUpdate dcim device bays update API
*/
func (a *Client) DcimDeviceBaysUpdate(params *DcimDeviceBaysUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceBaysUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-bays_update",
		Method:             "PUT",
		PathPattern:        "/dcim/device-bays/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceBaysUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceBaysUpdateOK), nil

}

/*
DcimDeviceRolesCreate dcim device roles create API
*/
func (a *Client) DcimDeviceRolesCreate(params *DcimDeviceRolesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_create",
		Method:             "POST",
		PathPattern:        "/dcim/device-roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesCreateCreated), nil

}

/*
DcimDeviceRolesDelete dcim device roles delete API
*/
func (a *Client) DcimDeviceRolesDelete(params *DcimDeviceRolesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/device-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesDeleteNoContent), nil

}

/*
DcimDeviceRolesList dcim device roles list API
*/
func (a *Client) DcimDeviceRolesList(params *DcimDeviceRolesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_list",
		Method:             "GET",
		PathPattern:        "/dcim/device-roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesListOK), nil

}

/*
DcimDeviceRolesPartialUpdate dcim device roles partial update API
*/
func (a *Client) DcimDeviceRolesPartialUpdate(params *DcimDeviceRolesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/device-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesPartialUpdateOK), nil

}

/*
DcimDeviceRolesRead dcim device roles read API
*/
func (a *Client) DcimDeviceRolesRead(params *DcimDeviceRolesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_read",
		Method:             "GET",
		PathPattern:        "/dcim/device-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesReadOK), nil

}

/*
DcimDeviceRolesUpdate dcim device roles update API
*/
func (a *Client) DcimDeviceRolesUpdate(params *DcimDeviceRolesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceRolesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-roles_update",
		Method:             "PUT",
		PathPattern:        "/dcim/device-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceRolesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceRolesUpdateOK), nil

}

/*
DcimDeviceTypesCreate dcim device types create API
*/
func (a *Client) DcimDeviceTypesCreate(params *DcimDeviceTypesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_create",
		Method:             "POST",
		PathPattern:        "/dcim/device-types/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesCreateCreated), nil

}

/*
DcimDeviceTypesDelete dcim device types delete API
*/
func (a *Client) DcimDeviceTypesDelete(params *DcimDeviceTypesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/device-types/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesDeleteNoContent), nil

}

/*
DcimDeviceTypesList dcim device types list API
*/
func (a *Client) DcimDeviceTypesList(params *DcimDeviceTypesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_list",
		Method:             "GET",
		PathPattern:        "/dcim/device-types/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesListOK), nil

}

/*
DcimDeviceTypesPartialUpdate dcim device types partial update API
*/
func (a *Client) DcimDeviceTypesPartialUpdate(params *DcimDeviceTypesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/device-types/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesPartialUpdateOK), nil

}

/*
DcimDeviceTypesRead dcim device types read API
*/
func (a *Client) DcimDeviceTypesRead(params *DcimDeviceTypesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_read",
		Method:             "GET",
		PathPattern:        "/dcim/device-types/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesReadOK), nil

}

/*
DcimDeviceTypesUpdate dcim device types update API
*/
func (a *Client) DcimDeviceTypesUpdate(params *DcimDeviceTypesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDeviceTypesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_device-types_update",
		Method:             "PUT",
		PathPattern:        "/dcim/device-types/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimDeviceTypesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimDeviceTypesUpdateOK), nil

}

/*
DcimDevicesCreate dcim devices create API
*/
func (a *Client) DcimDevicesCreate(params *DcimDevicesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesCreateParams()
	}

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

}

/*
DcimDevicesDelete dcim devices delete API
*/
func (a *Client) DcimDevicesDelete(params *DcimDevicesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesDeleteParams()
	}

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

}

/*
DcimDevicesList dcim devices list API
*/
func (a *Client) DcimDevicesList(params *DcimDevicesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesListParams()
	}

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

}

/*
DcimDevicesNapalm Execute a NAPALM method on a Device
*/
func (a *Client) DcimDevicesNapalm(params *DcimDevicesNapalmParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesNapalmOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesNapalmParams()
	}

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

}

/*
DcimDevicesPartialUpdate dcim devices partial update API
*/
func (a *Client) DcimDevicesPartialUpdate(params *DcimDevicesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesPartialUpdateParams()
	}

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

}

/*
DcimDevicesRead dcim devices read API
*/
func (a *Client) DcimDevicesRead(params *DcimDevicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesReadParams()
	}

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

}

/*
DcimDevicesUpdate dcim devices update API
*/
func (a *Client) DcimDevicesUpdate(params *DcimDevicesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimDevicesUpdateParams()
	}

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

}

/*
DcimInterfaceConnectionsCreate dcim interface connections create API
*/
func (a *Client) DcimInterfaceConnectionsCreate(params *DcimInterfaceConnectionsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_create",
		Method:             "POST",
		PathPattern:        "/dcim/interface-connections/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsCreateCreated), nil

}

/*
DcimInterfaceConnectionsDelete dcim interface connections delete API
*/
func (a *Client) DcimInterfaceConnectionsDelete(params *DcimInterfaceConnectionsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/interface-connections/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsDeleteNoContent), nil

}

/*
DcimInterfaceConnectionsList dcim interface connections list API
*/
func (a *Client) DcimInterfaceConnectionsList(params *DcimInterfaceConnectionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_list",
		Method:             "GET",
		PathPattern:        "/dcim/interface-connections/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsListOK), nil

}

/*
DcimInterfaceConnectionsPartialUpdate dcim interface connections partial update API
*/
func (a *Client) DcimInterfaceConnectionsPartialUpdate(params *DcimInterfaceConnectionsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/interface-connections/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsPartialUpdateOK), nil

}

/*
DcimInterfaceConnectionsRead dcim interface connections read API
*/
func (a *Client) DcimInterfaceConnectionsRead(params *DcimInterfaceConnectionsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_read",
		Method:             "GET",
		PathPattern:        "/dcim/interface-connections/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsReadOK), nil

}

/*
DcimInterfaceConnectionsUpdate dcim interface connections update API
*/
func (a *Client) DcimInterfaceConnectionsUpdate(params *DcimInterfaceConnectionsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceConnectionsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceConnectionsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-connections_update",
		Method:             "PUT",
		PathPattern:        "/dcim/interface-connections/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceConnectionsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceConnectionsUpdateOK), nil

}

/*
DcimInterfaceTemplatesCreate dcim interface templates create API
*/
func (a *Client) DcimInterfaceTemplatesCreate(params *DcimInterfaceTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/interface-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesCreateCreated), nil

}

/*
DcimInterfaceTemplatesDelete dcim interface templates delete API
*/
func (a *Client) DcimInterfaceTemplatesDelete(params *DcimInterfaceTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/interface-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesDeleteNoContent), nil

}

/*
DcimInterfaceTemplatesList dcim interface templates list API
*/
func (a *Client) DcimInterfaceTemplatesList(params *DcimInterfaceTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/interface-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesListOK), nil

}

/*
DcimInterfaceTemplatesPartialUpdate dcim interface templates partial update API
*/
func (a *Client) DcimInterfaceTemplatesPartialUpdate(params *DcimInterfaceTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/interface-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesPartialUpdateOK), nil

}

/*
DcimInterfaceTemplatesRead dcim interface templates read API
*/
func (a *Client) DcimInterfaceTemplatesRead(params *DcimInterfaceTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/interface-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesReadOK), nil

}

/*
DcimInterfaceTemplatesUpdate dcim interface templates update API
*/
func (a *Client) DcimInterfaceTemplatesUpdate(params *DcimInterfaceTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfaceTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfaceTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interface-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/interface-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfaceTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfaceTemplatesUpdateOK), nil

}

/*
DcimInterfacesCreate dcim interfaces create API
*/
func (a *Client) DcimInterfacesCreate(params *DcimInterfacesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesCreateParams()
	}

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

}

/*
DcimInterfacesDelete dcim interfaces delete API
*/
func (a *Client) DcimInterfacesDelete(params *DcimInterfacesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interfaces_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/interfaces/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfacesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfacesDeleteNoContent), nil

}

/*
DcimInterfacesGraphs A convenience method for rendering graphs for a particular interface.
*/
func (a *Client) DcimInterfacesGraphs(params *DcimInterfacesGraphsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesGraphsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesGraphsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interfaces_graphs",
		Method:             "GET",
		PathPattern:        "/dcim/interfaces/{id}/graphs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfacesGraphsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfacesGraphsOK), nil

}

/*
DcimInterfacesList dcim interfaces list API
*/
func (a *Client) DcimInterfacesList(params *DcimInterfacesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesListParams()
	}

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

}

/*
DcimInterfacesPartialUpdate dcim interfaces partial update API
*/
func (a *Client) DcimInterfacesPartialUpdate(params *DcimInterfacesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interfaces_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/interfaces/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfacesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfacesPartialUpdateOK), nil

}

/*
DcimInterfacesRead dcim interfaces read API
*/
func (a *Client) DcimInterfacesRead(params *DcimInterfacesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesReadParams()
	}

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

}

/*
DcimInterfacesUpdate dcim interfaces update API
*/
func (a *Client) DcimInterfacesUpdate(params *DcimInterfacesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInterfacesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_interfaces_update",
		Method:             "PUT",
		PathPattern:        "/dcim/interfaces/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInterfacesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInterfacesUpdateOK), nil

}

/*
DcimInventoryItemsCreate dcim inventory items create API
*/
func (a *Client) DcimInventoryItemsCreate(params *DcimInventoryItemsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_create",
		Method:             "POST",
		PathPattern:        "/dcim/inventory-items/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsCreateCreated), nil

}

/*
DcimInventoryItemsDelete dcim inventory items delete API
*/
func (a *Client) DcimInventoryItemsDelete(params *DcimInventoryItemsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/inventory-items/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsDeleteNoContent), nil

}

/*
DcimInventoryItemsList dcim inventory items list API
*/
func (a *Client) DcimInventoryItemsList(params *DcimInventoryItemsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_list",
		Method:             "GET",
		PathPattern:        "/dcim/inventory-items/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsListOK), nil

}

/*
DcimInventoryItemsPartialUpdate dcim inventory items partial update API
*/
func (a *Client) DcimInventoryItemsPartialUpdate(params *DcimInventoryItemsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/inventory-items/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsPartialUpdateOK), nil

}

/*
DcimInventoryItemsRead dcim inventory items read API
*/
func (a *Client) DcimInventoryItemsRead(params *DcimInventoryItemsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_read",
		Method:             "GET",
		PathPattern:        "/dcim/inventory-items/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsReadOK), nil

}

/*
DcimInventoryItemsUpdate dcim inventory items update API
*/
func (a *Client) DcimInventoryItemsUpdate(params *DcimInventoryItemsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimInventoryItemsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_inventory-items_update",
		Method:             "PUT",
		PathPattern:        "/dcim/inventory-items/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimInventoryItemsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimInventoryItemsUpdateOK), nil

}

/*
DcimManufacturersCreate dcim manufacturers create API
*/
func (a *Client) DcimManufacturersCreate(params *DcimManufacturersCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersCreateParams()
	}

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

}

/*
DcimManufacturersDelete dcim manufacturers delete API
*/
func (a *Client) DcimManufacturersDelete(params *DcimManufacturersDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_manufacturers_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/manufacturers/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimManufacturersDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimManufacturersDeleteNoContent), nil

}

/*
DcimManufacturersList dcim manufacturers list API
*/
func (a *Client) DcimManufacturersList(params *DcimManufacturersListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersListParams()
	}

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

}

/*
DcimManufacturersPartialUpdate dcim manufacturers partial update API
*/
func (a *Client) DcimManufacturersPartialUpdate(params *DcimManufacturersPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_manufacturers_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/manufacturers/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimManufacturersPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimManufacturersPartialUpdateOK), nil

}

/*
DcimManufacturersRead dcim manufacturers read API
*/
func (a *Client) DcimManufacturersRead(params *DcimManufacturersReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersReadParams()
	}

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

}

/*
DcimManufacturersUpdate dcim manufacturers update API
*/
func (a *Client) DcimManufacturersUpdate(params *DcimManufacturersUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimManufacturersUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_manufacturers_update",
		Method:             "PUT",
		PathPattern:        "/dcim/manufacturers/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimManufacturersUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimManufacturersUpdateOK), nil

}

/*
DcimPlatformsCreate dcim platforms create API
*/
func (a *Client) DcimPlatformsCreate(params *DcimPlatformsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsCreateParams()
	}

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

}

/*
DcimPlatformsDelete dcim platforms delete API
*/
func (a *Client) DcimPlatformsDelete(params *DcimPlatformsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_platforms_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/platforms/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPlatformsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPlatformsDeleteNoContent), nil

}

/*
DcimPlatformsList dcim platforms list API
*/
func (a *Client) DcimPlatformsList(params *DcimPlatformsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsListParams()
	}

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

}

/*
DcimPlatformsPartialUpdate dcim platforms partial update API
*/
func (a *Client) DcimPlatformsPartialUpdate(params *DcimPlatformsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_platforms_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/platforms/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPlatformsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPlatformsPartialUpdateOK), nil

}

/*
DcimPlatformsRead dcim platforms read API
*/
func (a *Client) DcimPlatformsRead(params *DcimPlatformsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsReadParams()
	}

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

}

/*
DcimPlatformsUpdate dcim platforms update API
*/
func (a *Client) DcimPlatformsUpdate(params *DcimPlatformsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPlatformsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_platforms_update",
		Method:             "PUT",
		PathPattern:        "/dcim/platforms/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPlatformsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPlatformsUpdateOK), nil

}

/*
DcimPowerConnectionsList dcim power connections list API
*/
func (a *Client) DcimPowerConnectionsList(params *DcimPowerConnectionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerConnectionsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerConnectionsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-connections_list",
		Method:             "GET",
		PathPattern:        "/dcim/power-connections/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerConnectionsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerConnectionsListOK), nil

}

/*
DcimPowerOutletTemplatesCreate dcim power outlet templates create API
*/
func (a *Client) DcimPowerOutletTemplatesCreate(params *DcimPowerOutletTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/power-outlet-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesCreateCreated), nil

}

/*
DcimPowerOutletTemplatesDelete dcim power outlet templates delete API
*/
func (a *Client) DcimPowerOutletTemplatesDelete(params *DcimPowerOutletTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/power-outlet-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesDeleteNoContent), nil

}

/*
DcimPowerOutletTemplatesList dcim power outlet templates list API
*/
func (a *Client) DcimPowerOutletTemplatesList(params *DcimPowerOutletTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/power-outlet-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesListOK), nil

}

/*
DcimPowerOutletTemplatesPartialUpdate dcim power outlet templates partial update API
*/
func (a *Client) DcimPowerOutletTemplatesPartialUpdate(params *DcimPowerOutletTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/power-outlet-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesPartialUpdateOK), nil

}

/*
DcimPowerOutletTemplatesRead dcim power outlet templates read API
*/
func (a *Client) DcimPowerOutletTemplatesRead(params *DcimPowerOutletTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/power-outlet-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesReadOK), nil

}

/*
DcimPowerOutletTemplatesUpdate dcim power outlet templates update API
*/
func (a *Client) DcimPowerOutletTemplatesUpdate(params *DcimPowerOutletTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlet-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/power-outlet-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletTemplatesUpdateOK), nil

}

/*
DcimPowerOutletsCreate dcim power outlets create API
*/
func (a *Client) DcimPowerOutletsCreate(params *DcimPowerOutletsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_create",
		Method:             "POST",
		PathPattern:        "/dcim/power-outlets/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsCreateCreated), nil

}

/*
DcimPowerOutletsDelete dcim power outlets delete API
*/
func (a *Client) DcimPowerOutletsDelete(params *DcimPowerOutletsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/power-outlets/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsDeleteNoContent), nil

}

/*
DcimPowerOutletsList dcim power outlets list API
*/
func (a *Client) DcimPowerOutletsList(params *DcimPowerOutletsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_list",
		Method:             "GET",
		PathPattern:        "/dcim/power-outlets/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsListOK), nil

}

/*
DcimPowerOutletsPartialUpdate dcim power outlets partial update API
*/
func (a *Client) DcimPowerOutletsPartialUpdate(params *DcimPowerOutletsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/power-outlets/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsPartialUpdateOK), nil

}

/*
DcimPowerOutletsRead dcim power outlets read API
*/
func (a *Client) DcimPowerOutletsRead(params *DcimPowerOutletsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_read",
		Method:             "GET",
		PathPattern:        "/dcim/power-outlets/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsReadOK), nil

}

/*
DcimPowerOutletsUpdate dcim power outlets update API
*/
func (a *Client) DcimPowerOutletsUpdate(params *DcimPowerOutletsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerOutletsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-outlets_update",
		Method:             "PUT",
		PathPattern:        "/dcim/power-outlets/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerOutletsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerOutletsUpdateOK), nil

}

/*
DcimPowerPortTemplatesCreate dcim power port templates create API
*/
func (a *Client) DcimPowerPortTemplatesCreate(params *DcimPowerPortTemplatesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_create",
		Method:             "POST",
		PathPattern:        "/dcim/power-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesCreateCreated), nil

}

/*
DcimPowerPortTemplatesDelete dcim power port templates delete API
*/
func (a *Client) DcimPowerPortTemplatesDelete(params *DcimPowerPortTemplatesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/power-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesDeleteNoContent), nil

}

/*
DcimPowerPortTemplatesList dcim power port templates list API
*/
func (a *Client) DcimPowerPortTemplatesList(params *DcimPowerPortTemplatesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_list",
		Method:             "GET",
		PathPattern:        "/dcim/power-port-templates/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesListOK), nil

}

/*
DcimPowerPortTemplatesPartialUpdate dcim power port templates partial update API
*/
func (a *Client) DcimPowerPortTemplatesPartialUpdate(params *DcimPowerPortTemplatesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/power-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesPartialUpdateOK), nil

}

/*
DcimPowerPortTemplatesRead dcim power port templates read API
*/
func (a *Client) DcimPowerPortTemplatesRead(params *DcimPowerPortTemplatesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_read",
		Method:             "GET",
		PathPattern:        "/dcim/power-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesReadOK), nil

}

/*
DcimPowerPortTemplatesUpdate dcim power port templates update API
*/
func (a *Client) DcimPowerPortTemplatesUpdate(params *DcimPowerPortTemplatesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortTemplatesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortTemplatesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-port-templates_update",
		Method:             "PUT",
		PathPattern:        "/dcim/power-port-templates/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortTemplatesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortTemplatesUpdateOK), nil

}

/*
DcimPowerPortsCreate dcim power ports create API
*/
func (a *Client) DcimPowerPortsCreate(params *DcimPowerPortsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_create",
		Method:             "POST",
		PathPattern:        "/dcim/power-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsCreateCreated), nil

}

/*
DcimPowerPortsDelete dcim power ports delete API
*/
func (a *Client) DcimPowerPortsDelete(params *DcimPowerPortsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/power-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsDeleteNoContent), nil

}

/*
DcimPowerPortsList dcim power ports list API
*/
func (a *Client) DcimPowerPortsList(params *DcimPowerPortsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_list",
		Method:             "GET",
		PathPattern:        "/dcim/power-ports/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsListOK), nil

}

/*
DcimPowerPortsPartialUpdate dcim power ports partial update API
*/
func (a *Client) DcimPowerPortsPartialUpdate(params *DcimPowerPortsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/power-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsPartialUpdateOK), nil

}

/*
DcimPowerPortsRead dcim power ports read API
*/
func (a *Client) DcimPowerPortsRead(params *DcimPowerPortsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_read",
		Method:             "GET",
		PathPattern:        "/dcim/power-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsReadOK), nil

}

/*
DcimPowerPortsUpdate dcim power ports update API
*/
func (a *Client) DcimPowerPortsUpdate(params *DcimPowerPortsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimPowerPortsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_power-ports_update",
		Method:             "PUT",
		PathPattern:        "/dcim/power-ports/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimPowerPortsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimPowerPortsUpdateOK), nil

}

/*
DcimRackGroupsCreate dcim rack groups create API
*/
func (a *Client) DcimRackGroupsCreate(params *DcimRackGroupsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_create",
		Method:             "POST",
		PathPattern:        "/dcim/rack-groups/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsCreateCreated), nil

}

/*
DcimRackGroupsDelete dcim rack groups delete API
*/
func (a *Client) DcimRackGroupsDelete(params *DcimRackGroupsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/rack-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsDeleteNoContent), nil

}

/*
DcimRackGroupsList dcim rack groups list API
*/
func (a *Client) DcimRackGroupsList(params *DcimRackGroupsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_list",
		Method:             "GET",
		PathPattern:        "/dcim/rack-groups/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsListOK), nil

}

/*
DcimRackGroupsPartialUpdate dcim rack groups partial update API
*/
func (a *Client) DcimRackGroupsPartialUpdate(params *DcimRackGroupsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/rack-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsPartialUpdateOK), nil

}

/*
DcimRackGroupsRead dcim rack groups read API
*/
func (a *Client) DcimRackGroupsRead(params *DcimRackGroupsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_read",
		Method:             "GET",
		PathPattern:        "/dcim/rack-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsReadOK), nil

}

/*
DcimRackGroupsUpdate dcim rack groups update API
*/
func (a *Client) DcimRackGroupsUpdate(params *DcimRackGroupsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackGroupsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-groups_update",
		Method:             "PUT",
		PathPattern:        "/dcim/rack-groups/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackGroupsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackGroupsUpdateOK), nil

}

/*
DcimRackReservationsCreate dcim rack reservations create API
*/
func (a *Client) DcimRackReservationsCreate(params *DcimRackReservationsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_create",
		Method:             "POST",
		PathPattern:        "/dcim/rack-reservations/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsCreateCreated), nil

}

/*
DcimRackReservationsDelete dcim rack reservations delete API
*/
func (a *Client) DcimRackReservationsDelete(params *DcimRackReservationsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/rack-reservations/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsDeleteNoContent), nil

}

/*
DcimRackReservationsList dcim rack reservations list API
*/
func (a *Client) DcimRackReservationsList(params *DcimRackReservationsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_list",
		Method:             "GET",
		PathPattern:        "/dcim/rack-reservations/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsListOK), nil

}

/*
DcimRackReservationsPartialUpdate dcim rack reservations partial update API
*/
func (a *Client) DcimRackReservationsPartialUpdate(params *DcimRackReservationsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/rack-reservations/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsPartialUpdateOK), nil

}

/*
DcimRackReservationsRead dcim rack reservations read API
*/
func (a *Client) DcimRackReservationsRead(params *DcimRackReservationsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_read",
		Method:             "GET",
		PathPattern:        "/dcim/rack-reservations/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsReadOK), nil

}

/*
DcimRackReservationsUpdate dcim rack reservations update API
*/
func (a *Client) DcimRackReservationsUpdate(params *DcimRackReservationsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackReservationsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-reservations_update",
		Method:             "PUT",
		PathPattern:        "/dcim/rack-reservations/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackReservationsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackReservationsUpdateOK), nil

}

/*
DcimRackRolesCreate dcim rack roles create API
*/
func (a *Client) DcimRackRolesCreate(params *DcimRackRolesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_create",
		Method:             "POST",
		PathPattern:        "/dcim/rack-roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesCreateCreated), nil

}

/*
DcimRackRolesDelete dcim rack roles delete API
*/
func (a *Client) DcimRackRolesDelete(params *DcimRackRolesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/rack-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesDeleteNoContent), nil

}

/*
DcimRackRolesList dcim rack roles list API
*/
func (a *Client) DcimRackRolesList(params *DcimRackRolesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_list",
		Method:             "GET",
		PathPattern:        "/dcim/rack-roles/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesListOK), nil

}

/*
DcimRackRolesPartialUpdate dcim rack roles partial update API
*/
func (a *Client) DcimRackRolesPartialUpdate(params *DcimRackRolesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/rack-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesPartialUpdateOK), nil

}

/*
DcimRackRolesRead dcim rack roles read API
*/
func (a *Client) DcimRackRolesRead(params *DcimRackRolesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_read",
		Method:             "GET",
		PathPattern:        "/dcim/rack-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesReadOK), nil

}

/*
DcimRackRolesUpdate dcim rack roles update API
*/
func (a *Client) DcimRackRolesUpdate(params *DcimRackRolesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRackRolesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_rack-roles_update",
		Method:             "PUT",
		PathPattern:        "/dcim/rack-roles/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRackRolesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRackRolesUpdateOK), nil

}

/*
DcimRacksCreate dcim racks create API
*/
func (a *Client) DcimRacksCreate(params *DcimRacksCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksCreateParams()
	}

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

}

/*
DcimRacksDelete dcim racks delete API
*/
func (a *Client) DcimRacksDelete(params *DcimRacksDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_racks_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/racks/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRacksDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRacksDeleteNoContent), nil

}

/*
DcimRacksList dcim racks list API
*/
func (a *Client) DcimRacksList(params *DcimRacksListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksListParams()
	}

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

}

/*
DcimRacksPartialUpdate dcim racks partial update API
*/
func (a *Client) DcimRacksPartialUpdate(params *DcimRacksPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_racks_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/racks/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRacksPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRacksPartialUpdateOK), nil

}

/*
DcimRacksRead dcim racks read API
*/
func (a *Client) DcimRacksRead(params *DcimRacksReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksReadParams()
	}

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

}

/*
DcimRacksUnits List rack units (by rack)
*/
func (a *Client) DcimRacksUnits(params *DcimRacksUnitsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksUnitsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksUnitsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_racks_units",
		Method:             "GET",
		PathPattern:        "/dcim/racks/{id}/units/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRacksUnitsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRacksUnitsOK), nil

}

/*
DcimRacksUpdate dcim racks update API
*/
func (a *Client) DcimRacksUpdate(params *DcimRacksUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRacksUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_racks_update",
		Method:             "PUT",
		PathPattern:        "/dcim/racks/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRacksUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRacksUpdateOK), nil

}

/*
DcimRegionsCreate dcim regions create API
*/
func (a *Client) DcimRegionsCreate(params *DcimRegionsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsCreateParams()
	}

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

}

/*
DcimRegionsDelete dcim regions delete API
*/
func (a *Client) DcimRegionsDelete(params *DcimRegionsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_regions_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/regions/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRegionsDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRegionsDeleteNoContent), nil

}

/*
DcimRegionsList dcim regions list API
*/
func (a *Client) DcimRegionsList(params *DcimRegionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsListParams()
	}

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

}

/*
DcimRegionsPartialUpdate dcim regions partial update API
*/
func (a *Client) DcimRegionsPartialUpdate(params *DcimRegionsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_regions_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/regions/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRegionsPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRegionsPartialUpdateOK), nil

}

/*
DcimRegionsRead dcim regions read API
*/
func (a *Client) DcimRegionsRead(params *DcimRegionsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsReadParams()
	}

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

}

/*
DcimRegionsUpdate dcim regions update API
*/
func (a *Client) DcimRegionsUpdate(params *DcimRegionsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimRegionsUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_regions_update",
		Method:             "PUT",
		PathPattern:        "/dcim/regions/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimRegionsUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimRegionsUpdateOK), nil

}

/*
DcimSitesCreate dcim sites create API
*/
func (a *Client) DcimSitesCreate(params *DcimSitesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesCreateParams()
	}

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

}

/*
DcimSitesDelete dcim sites delete API
*/
func (a *Client) DcimSitesDelete(params *DcimSitesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_sites_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/sites/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimSitesDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimSitesDeleteNoContent), nil

}

/*
DcimSitesGraphs A convenience method for rendering graphs for a particular site.
*/
func (a *Client) DcimSitesGraphs(params *DcimSitesGraphsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesGraphsOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesGraphsParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_sites_graphs",
		Method:             "GET",
		PathPattern:        "/dcim/sites/{id}/graphs/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimSitesGraphsReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimSitesGraphsOK), nil

}

/*
DcimSitesList dcim sites list API
*/
func (a *Client) DcimSitesList(params *DcimSitesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesListParams()
	}

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

}

/*
DcimSitesPartialUpdate dcim sites partial update API
*/
func (a *Client) DcimSitesPartialUpdate(params *DcimSitesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_sites_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/sites/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimSitesPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimSitesPartialUpdateOK), nil

}

/*
DcimSitesRead dcim sites read API
*/
func (a *Client) DcimSitesRead(params *DcimSitesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesReadParams()
	}

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

}

/*
DcimSitesUpdate dcim sites update API
*/
func (a *Client) DcimSitesUpdate(params *DcimSitesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimSitesUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_sites_update",
		Method:             "PUT",
		PathPattern:        "/dcim/sites/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimSitesUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimSitesUpdateOK), nil

}

/*
DcimVirtualChassisCreate dcim virtual chassis create API
*/
func (a *Client) DcimVirtualChassisCreate(params *DcimVirtualChassisCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisCreateCreated, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisCreateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_create",
		Method:             "POST",
		PathPattern:        "/dcim/virtual-chassis/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisCreateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisCreateCreated), nil

}

/*
DcimVirtualChassisDelete dcim virtual chassis delete API
*/
func (a *Client) DcimVirtualChassisDelete(params *DcimVirtualChassisDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisDeleteNoContent, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisDeleteParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_delete",
		Method:             "DELETE",
		PathPattern:        "/dcim/virtual-chassis/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisDeleteReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisDeleteNoContent), nil

}

/*
DcimVirtualChassisList dcim virtual chassis list API
*/
func (a *Client) DcimVirtualChassisList(params *DcimVirtualChassisListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisListOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisListParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_list",
		Method:             "GET",
		PathPattern:        "/dcim/virtual-chassis/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisListReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisListOK), nil

}

/*
DcimVirtualChassisPartialUpdate dcim virtual chassis partial update API
*/
func (a *Client) DcimVirtualChassisPartialUpdate(params *DcimVirtualChassisPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisPartialUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisPartialUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_partial_update",
		Method:             "PATCH",
		PathPattern:        "/dcim/virtual-chassis/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisPartialUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisPartialUpdateOK), nil

}

/*
DcimVirtualChassisRead dcim virtual chassis read API
*/
func (a *Client) DcimVirtualChassisRead(params *DcimVirtualChassisReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisReadOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisReadParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_read",
		Method:             "GET",
		PathPattern:        "/dcim/virtual-chassis/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisReadReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisReadOK), nil

}

/*
DcimVirtualChassisUpdate dcim virtual chassis update API
*/
func (a *Client) DcimVirtualChassisUpdate(params *DcimVirtualChassisUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisUpdateOK, error) {
	// TODO: Validate the params before sending
	if params == nil {
		params = NewDcimVirtualChassisUpdateParams()
	}

	result, err := a.transport.Submit(&runtime.ClientOperation{
		ID:                 "dcim_virtual-chassis_update",
		Method:             "PUT",
		PathPattern:        "/dcim/virtual-chassis/{id}/",
		ProducesMediaTypes: []string{"application/json"},
		ConsumesMediaTypes: []string{"application/json"},
		Schemes:            []string{"http"},
		Params:             params,
		Reader:             &DcimVirtualChassisUpdateReader{formats: a.formats},
		AuthInfo:           authInfo,
		Context:            params.Context,
		Client:             params.HTTPClient,
	})
	if err != nil {
		return nil, err
	}
	return result.(*DcimVirtualChassisUpdateOK), nil

}

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