| // 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 |
| } |