Why Go
- Case Studies
  
  Common problems companies solve with Go
- Use Cases
  
  Stories about how and why companies use Go
- Security Policy
  
  How Go can help keep you secure by default
Learn
Docs
- Effective Go
  
  Tips for writing clear, performant, and idiomatic Go code
- Go User Manual
  
  A complete introduction to building software with Go
- Standard library
  
  Reference documentation for Go's standard library
- Release Notes
  
  Learn what's new in each Go release
Packages
Community
- Recorded Talks
  
  Videos from prior events
- Meetups
  
  Meet other local Go developers
- Conferences
  
  Learn and network with Go developers from around the world
- Go blog
  
  The Go project's official blog.
- Go project
  
  Get help and stay informed from Go
- Get connected

dcim

package

Go to main page

Versions in this module

v0

v0.0.2

Feb 11, 2021

v0.0.1

Feb 11, 2021

Changes in this version

+ type Client struct

+ func New(transport runtime.ClientTransport, formats strfmt.Registry) *Client

+ func (a *Client) DcimChoicesList(params *DcimChoicesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimChoicesListOK, error)

+ func (a *Client) DcimChoicesRead(params *DcimChoicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimChoicesReadOK, error)

+ func (a *Client) DcimConnectedDeviceList(params *DcimConnectedDeviceListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConnectedDeviceListOK, error)

+ func (a *Client) DcimConsoleConnectionsList(params *DcimConsoleConnectionsListParams, ...) (*DcimConsoleConnectionsListOK, error)

+ func (a *Client) DcimConsolePortTemplatesCreate(params *DcimConsolePortTemplatesCreateParams, ...) (*DcimConsolePortTemplatesCreateCreated, error)

+ func (a *Client) DcimConsolePortTemplatesDelete(params *DcimConsolePortTemplatesDeleteParams, ...) (*DcimConsolePortTemplatesDeleteNoContent, error)

+ func (a *Client) DcimConsolePortTemplatesList(params *DcimConsolePortTemplatesListParams, ...) (*DcimConsolePortTemplatesListOK, error)

+ func (a *Client) DcimConsolePortTemplatesPartialUpdate(params *DcimConsolePortTemplatesPartialUpdateParams, ...) (*DcimConsolePortTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimConsolePortTemplatesRead(params *DcimConsolePortTemplatesReadParams, ...) (*DcimConsolePortTemplatesReadOK, error)

+ func (a *Client) DcimConsolePortTemplatesUpdate(params *DcimConsolePortTemplatesUpdateParams, ...) (*DcimConsolePortTemplatesUpdateOK, error)

+ func (a *Client) DcimConsolePortsCreate(params *DcimConsolePortsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsCreateCreated, error)

+ func (a *Client) DcimConsolePortsDelete(params *DcimConsolePortsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsDeleteNoContent, error)

+ func (a *Client) DcimConsolePortsList(params *DcimConsolePortsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsListOK, error)

+ func (a *Client) DcimConsolePortsPartialUpdate(params *DcimConsolePortsPartialUpdateParams, ...) (*DcimConsolePortsPartialUpdateOK, error)

+ func (a *Client) DcimConsolePortsRead(params *DcimConsolePortsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsReadOK, error)

+ func (a *Client) DcimConsolePortsUpdate(params *DcimConsolePortsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimConsolePortsUpdateOK, error)

+ func (a *Client) DcimConsoleServerPortTemplatesCreate(params *DcimConsoleServerPortTemplatesCreateParams, ...) (*DcimConsoleServerPortTemplatesCreateCreated, error)

+ func (a *Client) DcimConsoleServerPortTemplatesDelete(params *DcimConsoleServerPortTemplatesDeleteParams, ...) (*DcimConsoleServerPortTemplatesDeleteNoContent, error)

+ func (a *Client) DcimConsoleServerPortTemplatesList(params *DcimConsoleServerPortTemplatesListParams, ...) (*DcimConsoleServerPortTemplatesListOK, error)

+ func (a *Client) DcimConsoleServerPortTemplatesPartialUpdate(params *DcimConsoleServerPortTemplatesPartialUpdateParams, ...) (*DcimConsoleServerPortTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimConsoleServerPortTemplatesRead(params *DcimConsoleServerPortTemplatesReadParams, ...) (*DcimConsoleServerPortTemplatesReadOK, error)

+ func (a *Client) DcimConsoleServerPortTemplatesUpdate(params *DcimConsoleServerPortTemplatesUpdateParams, ...) (*DcimConsoleServerPortTemplatesUpdateOK, error)

+ func (a *Client) DcimConsoleServerPortsCreate(params *DcimConsoleServerPortsCreateParams, ...) (*DcimConsoleServerPortsCreateCreated, error)

+ func (a *Client) DcimConsoleServerPortsDelete(params *DcimConsoleServerPortsDeleteParams, ...) (*DcimConsoleServerPortsDeleteNoContent, error)

+ func (a *Client) DcimConsoleServerPortsList(params *DcimConsoleServerPortsListParams, ...) (*DcimConsoleServerPortsListOK, error)

+ func (a *Client) DcimConsoleServerPortsPartialUpdate(params *DcimConsoleServerPortsPartialUpdateParams, ...) (*DcimConsoleServerPortsPartialUpdateOK, error)

+ func (a *Client) DcimConsoleServerPortsRead(params *DcimConsoleServerPortsReadParams, ...) (*DcimConsoleServerPortsReadOK, error)

+ func (a *Client) DcimConsoleServerPortsUpdate(params *DcimConsoleServerPortsUpdateParams, ...) (*DcimConsoleServerPortsUpdateOK, error)

+ func (a *Client) DcimDeviceBayTemplatesCreate(params *DcimDeviceBayTemplatesCreateParams, ...) (*DcimDeviceBayTemplatesCreateCreated, error)

+ func (a *Client) DcimDeviceBayTemplatesDelete(params *DcimDeviceBayTemplatesDeleteParams, ...) (*DcimDeviceBayTemplatesDeleteNoContent, error)

+ func (a *Client) DcimDeviceBayTemplatesList(params *DcimDeviceBayTemplatesListParams, ...) (*DcimDeviceBayTemplatesListOK, error)

+ func (a *Client) DcimDeviceBayTemplatesPartialUpdate(params *DcimDeviceBayTemplatesPartialUpdateParams, ...) (*DcimDeviceBayTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimDeviceBayTemplatesRead(params *DcimDeviceBayTemplatesReadParams, ...) (*DcimDeviceBayTemplatesReadOK, error)

+ func (a *Client) DcimDeviceBayTemplatesUpdate(params *DcimDeviceBayTemplatesUpdateParams, ...) (*DcimDeviceBayTemplatesUpdateOK, error)

+ func (a *Client) DcimDeviceBaysCreate(params *DcimDeviceBaysCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysCreateCreated, error)

+ func (a *Client) DcimDeviceBaysDelete(params *DcimDeviceBaysDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysDeleteNoContent, error)

+ func (a *Client) DcimDeviceBaysList(params *DcimDeviceBaysListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysListOK, error)

+ func (a *Client) DcimDeviceBaysPartialUpdate(params *DcimDeviceBaysPartialUpdateParams, ...) (*DcimDeviceBaysPartialUpdateOK, error)

+ func (a *Client) DcimDeviceBaysRead(params *DcimDeviceBaysReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysReadOK, error)

+ func (a *Client) DcimDeviceBaysUpdate(params *DcimDeviceBaysUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceBaysUpdateOK, error)

+ func (a *Client) DcimDeviceRolesCreate(params *DcimDeviceRolesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesCreateCreated, error)

+ func (a *Client) DcimDeviceRolesDelete(params *DcimDeviceRolesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesDeleteNoContent, error)

+ func (a *Client) DcimDeviceRolesList(params *DcimDeviceRolesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesListOK, error)

+ func (a *Client) DcimDeviceRolesPartialUpdate(params *DcimDeviceRolesPartialUpdateParams, ...) (*DcimDeviceRolesPartialUpdateOK, error)

+ func (a *Client) DcimDeviceRolesRead(params *DcimDeviceRolesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesReadOK, error)

+ func (a *Client) DcimDeviceRolesUpdate(params *DcimDeviceRolesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceRolesUpdateOK, error)

+ func (a *Client) DcimDeviceTypesCreate(params *DcimDeviceTypesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesCreateCreated, error)

+ func (a *Client) DcimDeviceTypesDelete(params *DcimDeviceTypesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesDeleteNoContent, error)

+ func (a *Client) DcimDeviceTypesList(params *DcimDeviceTypesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesListOK, error)

+ func (a *Client) DcimDeviceTypesPartialUpdate(params *DcimDeviceTypesPartialUpdateParams, ...) (*DcimDeviceTypesPartialUpdateOK, error)

+ func (a *Client) DcimDeviceTypesRead(params *DcimDeviceTypesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesReadOK, error)

+ func (a *Client) DcimDeviceTypesUpdate(params *DcimDeviceTypesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDeviceTypesUpdateOK, error)

+ func (a *Client) DcimDevicesCreate(params *DcimDevicesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesCreateCreated, error)

+ func (a *Client) DcimDevicesDelete(params *DcimDevicesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesDeleteNoContent, error)

+ func (a *Client) DcimDevicesList(params *DcimDevicesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesListOK, error)

+ func (a *Client) DcimDevicesNapalm(params *DcimDevicesNapalmParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesNapalmOK, error)

+ func (a *Client) DcimDevicesPartialUpdate(params *DcimDevicesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesPartialUpdateOK, error)

+ func (a *Client) DcimDevicesRead(params *DcimDevicesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesReadOK, error)

+ func (a *Client) DcimDevicesUpdate(params *DcimDevicesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimDevicesUpdateOK, error)

+ func (a *Client) DcimInterfaceConnectionsCreate(params *DcimInterfaceConnectionsCreateParams, ...) (*DcimInterfaceConnectionsCreateCreated, error)

+ func (a *Client) DcimInterfaceConnectionsDelete(params *DcimInterfaceConnectionsDeleteParams, ...) (*DcimInterfaceConnectionsDeleteNoContent, error)

+ func (a *Client) DcimInterfaceConnectionsList(params *DcimInterfaceConnectionsListParams, ...) (*DcimInterfaceConnectionsListOK, error)

+ func (a *Client) DcimInterfaceConnectionsPartialUpdate(params *DcimInterfaceConnectionsPartialUpdateParams, ...) (*DcimInterfaceConnectionsPartialUpdateOK, error)

+ func (a *Client) DcimInterfaceConnectionsRead(params *DcimInterfaceConnectionsReadParams, ...) (*DcimInterfaceConnectionsReadOK, error)

+ func (a *Client) DcimInterfaceConnectionsUpdate(params *DcimInterfaceConnectionsUpdateParams, ...) (*DcimInterfaceConnectionsUpdateOK, error)

+ func (a *Client) DcimInterfaceTemplatesCreate(params *DcimInterfaceTemplatesCreateParams, ...) (*DcimInterfaceTemplatesCreateCreated, error)

+ func (a *Client) DcimInterfaceTemplatesDelete(params *DcimInterfaceTemplatesDeleteParams, ...) (*DcimInterfaceTemplatesDeleteNoContent, error)

+ func (a *Client) DcimInterfaceTemplatesList(params *DcimInterfaceTemplatesListParams, ...) (*DcimInterfaceTemplatesListOK, error)

+ func (a *Client) DcimInterfaceTemplatesPartialUpdate(params *DcimInterfaceTemplatesPartialUpdateParams, ...) (*DcimInterfaceTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimInterfaceTemplatesRead(params *DcimInterfaceTemplatesReadParams, ...) (*DcimInterfaceTemplatesReadOK, error)

+ func (a *Client) DcimInterfaceTemplatesUpdate(params *DcimInterfaceTemplatesUpdateParams, ...) (*DcimInterfaceTemplatesUpdateOK, error)

+ func (a *Client) DcimInterfacesCreate(params *DcimInterfacesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesCreateCreated, error)

+ func (a *Client) DcimInterfacesDelete(params *DcimInterfacesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesDeleteNoContent, error)

+ func (a *Client) DcimInterfacesGraphs(params *DcimInterfacesGraphsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesGraphsOK, error)

+ func (a *Client) DcimInterfacesList(params *DcimInterfacesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesListOK, error)

+ func (a *Client) DcimInterfacesPartialUpdate(params *DcimInterfacesPartialUpdateParams, ...) (*DcimInterfacesPartialUpdateOK, error)

+ func (a *Client) DcimInterfacesRead(params *DcimInterfacesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesReadOK, error)

+ func (a *Client) DcimInterfacesUpdate(params *DcimInterfacesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInterfacesUpdateOK, error)

+ func (a *Client) DcimInventoryItemsCreate(params *DcimInventoryItemsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsCreateCreated, error)

+ func (a *Client) DcimInventoryItemsDelete(params *DcimInventoryItemsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsDeleteNoContent, error)

+ func (a *Client) DcimInventoryItemsList(params *DcimInventoryItemsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsListOK, error)

+ func (a *Client) DcimInventoryItemsPartialUpdate(params *DcimInventoryItemsPartialUpdateParams, ...) (*DcimInventoryItemsPartialUpdateOK, error)

+ func (a *Client) DcimInventoryItemsRead(params *DcimInventoryItemsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsReadOK, error)

+ func (a *Client) DcimInventoryItemsUpdate(params *DcimInventoryItemsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimInventoryItemsUpdateOK, error)

+ func (a *Client) DcimManufacturersCreate(params *DcimManufacturersCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersCreateCreated, error)

+ func (a *Client) DcimManufacturersDelete(params *DcimManufacturersDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersDeleteNoContent, error)

+ func (a *Client) DcimManufacturersList(params *DcimManufacturersListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersListOK, error)

+ func (a *Client) DcimManufacturersPartialUpdate(params *DcimManufacturersPartialUpdateParams, ...) (*DcimManufacturersPartialUpdateOK, error)

+ func (a *Client) DcimManufacturersRead(params *DcimManufacturersReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersReadOK, error)

+ func (a *Client) DcimManufacturersUpdate(params *DcimManufacturersUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimManufacturersUpdateOK, error)

+ func (a *Client) DcimPlatformsCreate(params *DcimPlatformsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsCreateCreated, error)

+ func (a *Client) DcimPlatformsDelete(params *DcimPlatformsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsDeleteNoContent, error)

+ func (a *Client) DcimPlatformsList(params *DcimPlatformsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsListOK, error)

+ func (a *Client) DcimPlatformsPartialUpdate(params *DcimPlatformsPartialUpdateParams, ...) (*DcimPlatformsPartialUpdateOK, error)

+ func (a *Client) DcimPlatformsRead(params *DcimPlatformsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsReadOK, error)

+ func (a *Client) DcimPlatformsUpdate(params *DcimPlatformsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPlatformsUpdateOK, error)

+ func (a *Client) DcimPowerConnectionsList(params *DcimPowerConnectionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerConnectionsListOK, error)

+ func (a *Client) DcimPowerOutletTemplatesCreate(params *DcimPowerOutletTemplatesCreateParams, ...) (*DcimPowerOutletTemplatesCreateCreated, error)

+ func (a *Client) DcimPowerOutletTemplatesDelete(params *DcimPowerOutletTemplatesDeleteParams, ...) (*DcimPowerOutletTemplatesDeleteNoContent, error)

+ func (a *Client) DcimPowerOutletTemplatesList(params *DcimPowerOutletTemplatesListParams, ...) (*DcimPowerOutletTemplatesListOK, error)

+ func (a *Client) DcimPowerOutletTemplatesPartialUpdate(params *DcimPowerOutletTemplatesPartialUpdateParams, ...) (*DcimPowerOutletTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimPowerOutletTemplatesRead(params *DcimPowerOutletTemplatesReadParams, ...) (*DcimPowerOutletTemplatesReadOK, error)

+ func (a *Client) DcimPowerOutletTemplatesUpdate(params *DcimPowerOutletTemplatesUpdateParams, ...) (*DcimPowerOutletTemplatesUpdateOK, error)

+ func (a *Client) DcimPowerOutletsCreate(params *DcimPowerOutletsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsCreateCreated, error)

+ func (a *Client) DcimPowerOutletsDelete(params *DcimPowerOutletsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsDeleteNoContent, error)

+ func (a *Client) DcimPowerOutletsList(params *DcimPowerOutletsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsListOK, error)

+ func (a *Client) DcimPowerOutletsPartialUpdate(params *DcimPowerOutletsPartialUpdateParams, ...) (*DcimPowerOutletsPartialUpdateOK, error)

+ func (a *Client) DcimPowerOutletsRead(params *DcimPowerOutletsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsReadOK, error)

+ func (a *Client) DcimPowerOutletsUpdate(params *DcimPowerOutletsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerOutletsUpdateOK, error)

+ func (a *Client) DcimPowerPortTemplatesCreate(params *DcimPowerPortTemplatesCreateParams, ...) (*DcimPowerPortTemplatesCreateCreated, error)

+ func (a *Client) DcimPowerPortTemplatesDelete(params *DcimPowerPortTemplatesDeleteParams, ...) (*DcimPowerPortTemplatesDeleteNoContent, error)

+ func (a *Client) DcimPowerPortTemplatesList(params *DcimPowerPortTemplatesListParams, ...) (*DcimPowerPortTemplatesListOK, error)

+ func (a *Client) DcimPowerPortTemplatesPartialUpdate(params *DcimPowerPortTemplatesPartialUpdateParams, ...) (*DcimPowerPortTemplatesPartialUpdateOK, error)

+ func (a *Client) DcimPowerPortTemplatesRead(params *DcimPowerPortTemplatesReadParams, ...) (*DcimPowerPortTemplatesReadOK, error)

+ func (a *Client) DcimPowerPortTemplatesUpdate(params *DcimPowerPortTemplatesUpdateParams, ...) (*DcimPowerPortTemplatesUpdateOK, error)

+ func (a *Client) DcimPowerPortsCreate(params *DcimPowerPortsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsCreateCreated, error)

+ func (a *Client) DcimPowerPortsDelete(params *DcimPowerPortsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsDeleteNoContent, error)

+ func (a *Client) DcimPowerPortsList(params *DcimPowerPortsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsListOK, error)

+ func (a *Client) DcimPowerPortsPartialUpdate(params *DcimPowerPortsPartialUpdateParams, ...) (*DcimPowerPortsPartialUpdateOK, error)

+ func (a *Client) DcimPowerPortsRead(params *DcimPowerPortsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsReadOK, error)

+ func (a *Client) DcimPowerPortsUpdate(params *DcimPowerPortsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimPowerPortsUpdateOK, error)

+ func (a *Client) DcimRackGroupsCreate(params *DcimRackGroupsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsCreateCreated, error)

+ func (a *Client) DcimRackGroupsDelete(params *DcimRackGroupsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsDeleteNoContent, error)

+ func (a *Client) DcimRackGroupsList(params *DcimRackGroupsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsListOK, error)

+ func (a *Client) DcimRackGroupsPartialUpdate(params *DcimRackGroupsPartialUpdateParams, ...) (*DcimRackGroupsPartialUpdateOK, error)

+ func (a *Client) DcimRackGroupsRead(params *DcimRackGroupsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsReadOK, error)

+ func (a *Client) DcimRackGroupsUpdate(params *DcimRackGroupsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackGroupsUpdateOK, error)

+ func (a *Client) DcimRackReservationsCreate(params *DcimRackReservationsCreateParams, ...) (*DcimRackReservationsCreateCreated, error)

+ func (a *Client) DcimRackReservationsDelete(params *DcimRackReservationsDeleteParams, ...) (*DcimRackReservationsDeleteNoContent, error)

+ func (a *Client) DcimRackReservationsList(params *DcimRackReservationsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsListOK, error)

+ func (a *Client) DcimRackReservationsPartialUpdate(params *DcimRackReservationsPartialUpdateParams, ...) (*DcimRackReservationsPartialUpdateOK, error)

+ func (a *Client) DcimRackReservationsRead(params *DcimRackReservationsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackReservationsReadOK, error)

+ func (a *Client) DcimRackReservationsUpdate(params *DcimRackReservationsUpdateParams, ...) (*DcimRackReservationsUpdateOK, error)

+ func (a *Client) DcimRackRolesCreate(params *DcimRackRolesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesCreateCreated, error)

+ func (a *Client) DcimRackRolesDelete(params *DcimRackRolesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesDeleteNoContent, error)

+ func (a *Client) DcimRackRolesList(params *DcimRackRolesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesListOK, error)

+ func (a *Client) DcimRackRolesPartialUpdate(params *DcimRackRolesPartialUpdateParams, ...) (*DcimRackRolesPartialUpdateOK, error)

+ func (a *Client) DcimRackRolesRead(params *DcimRackRolesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesReadOK, error)

+ func (a *Client) DcimRackRolesUpdate(params *DcimRackRolesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRackRolesUpdateOK, error)

+ func (a *Client) DcimRacksCreate(params *DcimRacksCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksCreateCreated, error)

+ func (a *Client) DcimRacksDelete(params *DcimRacksDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksDeleteNoContent, error)

+ func (a *Client) DcimRacksList(params *DcimRacksListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksListOK, error)

+ func (a *Client) DcimRacksPartialUpdate(params *DcimRacksPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksPartialUpdateOK, error)

+ func (a *Client) DcimRacksRead(params *DcimRacksReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksReadOK, error)

+ func (a *Client) DcimRacksUnits(params *DcimRacksUnitsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksUnitsOK, error)

+ func (a *Client) DcimRacksUpdate(params *DcimRacksUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRacksUpdateOK, error)

+ func (a *Client) DcimRegionsCreate(params *DcimRegionsCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsCreateCreated, error)

+ func (a *Client) DcimRegionsDelete(params *DcimRegionsDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsDeleteNoContent, error)

+ func (a *Client) DcimRegionsList(params *DcimRegionsListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsListOK, error)

+ func (a *Client) DcimRegionsPartialUpdate(params *DcimRegionsPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsPartialUpdateOK, error)

+ func (a *Client) DcimRegionsRead(params *DcimRegionsReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsReadOK, error)

+ func (a *Client) DcimRegionsUpdate(params *DcimRegionsUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimRegionsUpdateOK, error)

+ func (a *Client) DcimSitesCreate(params *DcimSitesCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesCreateCreated, error)

+ func (a *Client) DcimSitesDelete(params *DcimSitesDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesDeleteNoContent, error)

+ func (a *Client) DcimSitesGraphs(params *DcimSitesGraphsParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesGraphsOK, error)

+ func (a *Client) DcimSitesList(params *DcimSitesListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesListOK, error)

+ func (a *Client) DcimSitesPartialUpdate(params *DcimSitesPartialUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesPartialUpdateOK, error)

+ func (a *Client) DcimSitesRead(params *DcimSitesReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesReadOK, error)

+ func (a *Client) DcimSitesUpdate(params *DcimSitesUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimSitesUpdateOK, error)

+ func (a *Client) DcimVirtualChassisCreate(params *DcimVirtualChassisCreateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisCreateCreated, error)

+ func (a *Client) DcimVirtualChassisDelete(params *DcimVirtualChassisDeleteParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisDeleteNoContent, error)

+ func (a *Client) DcimVirtualChassisList(params *DcimVirtualChassisListParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisListOK, error)

+ func (a *Client) DcimVirtualChassisPartialUpdate(params *DcimVirtualChassisPartialUpdateParams, ...) (*DcimVirtualChassisPartialUpdateOK, error)

+ func (a *Client) DcimVirtualChassisRead(params *DcimVirtualChassisReadParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisReadOK, error)

+ func (a *Client) DcimVirtualChassisUpdate(params *DcimVirtualChassisUpdateParams, authInfo runtime.ClientAuthInfoWriter) (*DcimVirtualChassisUpdateOK, error)

+ func (a *Client) SetTransport(transport runtime.ClientTransport)

+ type DcimChoicesListOK struct

+ func NewDcimChoicesListOK() *DcimChoicesListOK

+ func (o *DcimChoicesListOK) Error() string

+ type DcimChoicesListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ func NewDcimChoicesListParams() *DcimChoicesListParams

+ func NewDcimChoicesListParamsWithContext(ctx context.Context) *DcimChoicesListParams

+ func NewDcimChoicesListParamsWithHTTPClient(client *http.Client) *DcimChoicesListParams

+ func NewDcimChoicesListParamsWithTimeout(timeout time.Duration) *DcimChoicesListParams

+ func (o *DcimChoicesListParams) SetContext(ctx context.Context)

+ func (o *DcimChoicesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimChoicesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimChoicesListParams) WithContext(ctx context.Context) *DcimChoicesListParams

+ func (o *DcimChoicesListParams) WithHTTPClient(client *http.Client) *DcimChoicesListParams

+ func (o *DcimChoicesListParams) WithTimeout(timeout time.Duration) *DcimChoicesListParams

+ func (o *DcimChoicesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimChoicesListReader struct

+ func (o *DcimChoicesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimChoicesReadOK struct

+ func NewDcimChoicesReadOK() *DcimChoicesReadOK

+ func (o *DcimChoicesReadOK) Error() string

+ type DcimChoicesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID string

+ func NewDcimChoicesReadParams() *DcimChoicesReadParams

+ func NewDcimChoicesReadParamsWithContext(ctx context.Context) *DcimChoicesReadParams

+ func NewDcimChoicesReadParamsWithHTTPClient(client *http.Client) *DcimChoicesReadParams

+ func NewDcimChoicesReadParamsWithTimeout(timeout time.Duration) *DcimChoicesReadParams

+ func (o *DcimChoicesReadParams) SetContext(ctx context.Context)

+ func (o *DcimChoicesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimChoicesReadParams) SetID(id string)

+ func (o *DcimChoicesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimChoicesReadParams) WithContext(ctx context.Context) *DcimChoicesReadParams

+ func (o *DcimChoicesReadParams) WithHTTPClient(client *http.Client) *DcimChoicesReadParams

+ func (o *DcimChoicesReadParams) WithID(id string) *DcimChoicesReadParams

+ func (o *DcimChoicesReadParams) WithTimeout(timeout time.Duration) *DcimChoicesReadParams

+ func (o *DcimChoicesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimChoicesReadReader struct

+ func (o *DcimChoicesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConnectedDeviceListOK struct

+ Payload *models.Device

+ func NewDcimConnectedDeviceListOK() *DcimConnectedDeviceListOK

+ func (o *DcimConnectedDeviceListOK) Error() string

+ type DcimConnectedDeviceListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ PeerDevice string

+ PeerInterface string

+ func NewDcimConnectedDeviceListParams() *DcimConnectedDeviceListParams

+ func NewDcimConnectedDeviceListParamsWithContext(ctx context.Context) *DcimConnectedDeviceListParams

+ func NewDcimConnectedDeviceListParamsWithHTTPClient(client *http.Client) *DcimConnectedDeviceListParams

+ func NewDcimConnectedDeviceListParamsWithTimeout(timeout time.Duration) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) SetContext(ctx context.Context)

+ func (o *DcimConnectedDeviceListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConnectedDeviceListParams) SetPeerDevice(peerDevice string)

+ func (o *DcimConnectedDeviceListParams) SetPeerInterface(peerInterface string)

+ func (o *DcimConnectedDeviceListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConnectedDeviceListParams) WithContext(ctx context.Context) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) WithHTTPClient(client *http.Client) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) WithPeerDevice(peerDevice string) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) WithPeerInterface(peerInterface string) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) WithTimeout(timeout time.Duration) *DcimConnectedDeviceListParams

+ func (o *DcimConnectedDeviceListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConnectedDeviceListReader struct

+ func (o *DcimConnectedDeviceListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleConnectionsListOK struct

+ Payload *DcimConsoleConnectionsListOKBody

+ func NewDcimConsoleConnectionsListOK() *DcimConsoleConnectionsListOK

+ func (o *DcimConsoleConnectionsListOK) Error() string

+ type DcimConsoleConnectionsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConsolePort

+ func (o *DcimConsoleConnectionsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimConsoleConnectionsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimConsoleConnectionsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimConsoleConnectionsListParams struct

+ ConnectionStatus *string

+ Context context.Context

+ Device *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Site *string

+ func NewDcimConsoleConnectionsListParams() *DcimConsoleConnectionsListParams

+ func NewDcimConsoleConnectionsListParamsWithContext(ctx context.Context) *DcimConsoleConnectionsListParams

+ func NewDcimConsoleConnectionsListParamsWithHTTPClient(client *http.Client) *DcimConsoleConnectionsListParams

+ func NewDcimConsoleConnectionsListParamsWithTimeout(timeout time.Duration) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) SetConnectionStatus(connectionStatus *string)

+ func (o *DcimConsoleConnectionsListParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleConnectionsListParams) SetDevice(device *string)

+ func (o *DcimConsoleConnectionsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleConnectionsListParams) SetLimit(limit *int64)

+ func (o *DcimConsoleConnectionsListParams) SetName(name *string)

+ func (o *DcimConsoleConnectionsListParams) SetOffset(offset *int64)

+ func (o *DcimConsoleConnectionsListParams) SetSite(site *string)

+ func (o *DcimConsoleConnectionsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleConnectionsListParams) WithConnectionStatus(connectionStatus *string) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithContext(ctx context.Context) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithDevice(device *string) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithHTTPClient(client *http.Client) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithLimit(limit *int64) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithName(name *string) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithOffset(offset *int64) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithSite(site *string) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WithTimeout(timeout time.Duration) *DcimConsoleConnectionsListParams

+ func (o *DcimConsoleConnectionsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleConnectionsListReader struct

+ func (o *DcimConsoleConnectionsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesCreateCreated struct

+ Payload *models.ConsolePortTemplate

+ func NewDcimConsolePortTemplatesCreateCreated() *DcimConsolePortTemplatesCreateCreated

+ func (o *DcimConsolePortTemplatesCreateCreated) Error() string

+ type DcimConsolePortTemplatesCreateParams struct

+ Context context.Context

+ Data *models.ConsolePortTemplate

+ HTTPClient *http.Client

+ func NewDcimConsolePortTemplatesCreateParams() *DcimConsolePortTemplatesCreateParams

+ func NewDcimConsolePortTemplatesCreateParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesCreateParams

+ func NewDcimConsolePortTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesCreateParams

+ func NewDcimConsolePortTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesCreateParams

+ func (o *DcimConsolePortTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesCreateParams) SetData(data *models.ConsolePortTemplate)

+ func (o *DcimConsolePortTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesCreateParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesCreateParams

+ func (o *DcimConsolePortTemplatesCreateParams) WithData(data *models.ConsolePortTemplate) *DcimConsolePortTemplatesCreateParams

+ func (o *DcimConsolePortTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesCreateParams

+ func (o *DcimConsolePortTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesCreateParams

+ func (o *DcimConsolePortTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesCreateReader struct

+ func (o *DcimConsolePortTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesDeleteNoContent struct

+ func NewDcimConsolePortTemplatesDeleteNoContent() *DcimConsolePortTemplatesDeleteNoContent

+ func (o *DcimConsolePortTemplatesDeleteNoContent) Error() string

+ type DcimConsolePortTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortTemplatesDeleteParams() *DcimConsolePortTemplatesDeleteParams

+ func NewDcimConsolePortTemplatesDeleteParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesDeleteParams

+ func NewDcimConsolePortTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesDeleteParams

+ func NewDcimConsolePortTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesDeleteParams

+ func (o *DcimConsolePortTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimConsolePortTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesDeleteParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesDeleteParams

+ func (o *DcimConsolePortTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesDeleteParams

+ func (o *DcimConsolePortTemplatesDeleteParams) WithID(id int64) *DcimConsolePortTemplatesDeleteParams

+ func (o *DcimConsolePortTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesDeleteParams

+ func (o *DcimConsolePortTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesDeleteReader struct

+ func (o *DcimConsolePortTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesListOK struct

+ Payload *DcimConsolePortTemplatesListOKBody

+ func NewDcimConsolePortTemplatesListOK() *DcimConsolePortTemplatesListOK

+ func (o *DcimConsolePortTemplatesListOK) Error() string

+ type DcimConsolePortTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConsolePortTemplate

+ func (o *DcimConsolePortTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimConsolePortTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimConsolePortTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimConsolePortTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewDcimConsolePortTemplatesListParams() *DcimConsolePortTemplatesListParams

+ func NewDcimConsolePortTemplatesListParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesListParams

+ func NewDcimConsolePortTemplatesListParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesListParams

+ func NewDcimConsolePortTemplatesListParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimConsolePortTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimConsolePortTemplatesListParams) SetName(name *string)

+ func (o *DcimConsolePortTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimConsolePortTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesListParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithLimit(limit *int64) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithName(name *string) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithOffset(offset *int64) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesListParams

+ func (o *DcimConsolePortTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesListReader struct

+ func (o *DcimConsolePortTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesPartialUpdateOK struct

+ Payload *models.ConsolePortTemplate

+ func NewDcimConsolePortTemplatesPartialUpdateOK() *DcimConsolePortTemplatesPartialUpdateOK

+ func (o *DcimConsolePortTemplatesPartialUpdateOK) Error() string

+ type DcimConsolePortTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.ConsolePortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortTemplatesPartialUpdateParams() *DcimConsolePortTemplatesPartialUpdateParams

+ func NewDcimConsolePortTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesPartialUpdateParams

+ func NewDcimConsolePortTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesPartialUpdateParams

+ func NewDcimConsolePortTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) SetData(data *models.ConsolePortTemplate)

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WithData(data *models.ConsolePortTemplate) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WithID(id int64) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesPartialUpdateParams

+ func (o *DcimConsolePortTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesPartialUpdateReader struct

+ func (o *DcimConsolePortTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesReadOK struct

+ Payload *models.ConsolePortTemplate

+ func NewDcimConsolePortTemplatesReadOK() *DcimConsolePortTemplatesReadOK

+ func (o *DcimConsolePortTemplatesReadOK) Error() string

+ type DcimConsolePortTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortTemplatesReadParams() *DcimConsolePortTemplatesReadParams

+ func NewDcimConsolePortTemplatesReadParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesReadParams

+ func NewDcimConsolePortTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesReadParams

+ func NewDcimConsolePortTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesReadParams

+ func (o *DcimConsolePortTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesReadParams) SetID(id int64)

+ func (o *DcimConsolePortTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesReadParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesReadParams

+ func (o *DcimConsolePortTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesReadParams

+ func (o *DcimConsolePortTemplatesReadParams) WithID(id int64) *DcimConsolePortTemplatesReadParams

+ func (o *DcimConsolePortTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesReadParams

+ func (o *DcimConsolePortTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesReadReader struct

+ func (o *DcimConsolePortTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortTemplatesUpdateOK struct

+ Payload *models.ConsolePortTemplate

+ func NewDcimConsolePortTemplatesUpdateOK() *DcimConsolePortTemplatesUpdateOK

+ func (o *DcimConsolePortTemplatesUpdateOK) Error() string

+ type DcimConsolePortTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.ConsolePortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortTemplatesUpdateParams() *DcimConsolePortTemplatesUpdateParams

+ func NewDcimConsolePortTemplatesUpdateParamsWithContext(ctx context.Context) *DcimConsolePortTemplatesUpdateParams

+ func NewDcimConsolePortTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimConsolePortTemplatesUpdateParams

+ func NewDcimConsolePortTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortTemplatesUpdateParams) SetData(data *models.ConsolePortTemplate)

+ func (o *DcimConsolePortTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimConsolePortTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortTemplatesUpdateParams) WithContext(ctx context.Context) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) WithData(data *models.ConsolePortTemplate) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) WithID(id int64) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimConsolePortTemplatesUpdateParams

+ func (o *DcimConsolePortTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortTemplatesUpdateReader struct

+ func (o *DcimConsolePortTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsCreateCreated struct

+ Payload *models.ConsolePort

+ func NewDcimConsolePortsCreateCreated() *DcimConsolePortsCreateCreated

+ func (o *DcimConsolePortsCreateCreated) Error() string

+ type DcimConsolePortsCreateParams struct

+ Context context.Context

+ Data *models.ConsolePort

+ HTTPClient *http.Client

+ func NewDcimConsolePortsCreateParams() *DcimConsolePortsCreateParams

+ func NewDcimConsolePortsCreateParamsWithContext(ctx context.Context) *DcimConsolePortsCreateParams

+ func NewDcimConsolePortsCreateParamsWithHTTPClient(client *http.Client) *DcimConsolePortsCreateParams

+ func NewDcimConsolePortsCreateParamsWithTimeout(timeout time.Duration) *DcimConsolePortsCreateParams

+ func (o *DcimConsolePortsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsCreateParams) SetData(data *models.ConsolePort)

+ func (o *DcimConsolePortsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsCreateParams) WithContext(ctx context.Context) *DcimConsolePortsCreateParams

+ func (o *DcimConsolePortsCreateParams) WithData(data *models.ConsolePort) *DcimConsolePortsCreateParams

+ func (o *DcimConsolePortsCreateParams) WithHTTPClient(client *http.Client) *DcimConsolePortsCreateParams

+ func (o *DcimConsolePortsCreateParams) WithTimeout(timeout time.Duration) *DcimConsolePortsCreateParams

+ func (o *DcimConsolePortsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsCreateReader struct

+ func (o *DcimConsolePortsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsDeleteNoContent struct

+ func NewDcimConsolePortsDeleteNoContent() *DcimConsolePortsDeleteNoContent

+ func (o *DcimConsolePortsDeleteNoContent) Error() string

+ type DcimConsolePortsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortsDeleteParams() *DcimConsolePortsDeleteParams

+ func NewDcimConsolePortsDeleteParamsWithContext(ctx context.Context) *DcimConsolePortsDeleteParams

+ func NewDcimConsolePortsDeleteParamsWithHTTPClient(client *http.Client) *DcimConsolePortsDeleteParams

+ func NewDcimConsolePortsDeleteParamsWithTimeout(timeout time.Duration) *DcimConsolePortsDeleteParams

+ func (o *DcimConsolePortsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsDeleteParams) SetID(id int64)

+ func (o *DcimConsolePortsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsDeleteParams) WithContext(ctx context.Context) *DcimConsolePortsDeleteParams

+ func (o *DcimConsolePortsDeleteParams) WithHTTPClient(client *http.Client) *DcimConsolePortsDeleteParams

+ func (o *DcimConsolePortsDeleteParams) WithID(id int64) *DcimConsolePortsDeleteParams

+ func (o *DcimConsolePortsDeleteParams) WithTimeout(timeout time.Duration) *DcimConsolePortsDeleteParams

+ func (o *DcimConsolePortsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsDeleteReader struct

+ func (o *DcimConsolePortsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsListOK struct

+ Payload *DcimConsolePortsListOKBody

+ func NewDcimConsolePortsListOK() *DcimConsolePortsListOK

+ func (o *DcimConsolePortsListOK) Error() string

+ type DcimConsolePortsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConsolePort

+ func (o *DcimConsolePortsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimConsolePortsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimConsolePortsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimConsolePortsListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Tag *string

+ func NewDcimConsolePortsListParams() *DcimConsolePortsListParams

+ func NewDcimConsolePortsListParamsWithContext(ctx context.Context) *DcimConsolePortsListParams

+ func NewDcimConsolePortsListParamsWithHTTPClient(client *http.Client) *DcimConsolePortsListParams

+ func NewDcimConsolePortsListParamsWithTimeout(timeout time.Duration) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsListParams) SetDevice(device *string)

+ func (o *DcimConsolePortsListParams) SetDeviceID(deviceID *string)

+ func (o *DcimConsolePortsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsListParams) SetLimit(limit *int64)

+ func (o *DcimConsolePortsListParams) SetName(name *string)

+ func (o *DcimConsolePortsListParams) SetOffset(offset *int64)

+ func (o *DcimConsolePortsListParams) SetTag(tag *string)

+ func (o *DcimConsolePortsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsListParams) WithContext(ctx context.Context) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithDevice(device *string) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithDeviceID(deviceID *string) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithHTTPClient(client *http.Client) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithLimit(limit *int64) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithName(name *string) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithOffset(offset *int64) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithTag(tag *string) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WithTimeout(timeout time.Duration) *DcimConsolePortsListParams

+ func (o *DcimConsolePortsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsListReader struct

+ func (o *DcimConsolePortsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsPartialUpdateOK struct

+ Payload *models.ConsolePort

+ func NewDcimConsolePortsPartialUpdateOK() *DcimConsolePortsPartialUpdateOK

+ func (o *DcimConsolePortsPartialUpdateOK) Error() string

+ type DcimConsolePortsPartialUpdateParams struct

+ Context context.Context

+ Data *models.ConsolePort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortsPartialUpdateParams() *DcimConsolePortsPartialUpdateParams

+ func NewDcimConsolePortsPartialUpdateParamsWithContext(ctx context.Context) *DcimConsolePortsPartialUpdateParams

+ func NewDcimConsolePortsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimConsolePortsPartialUpdateParams

+ func NewDcimConsolePortsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsPartialUpdateParams) SetData(data *models.ConsolePort)

+ func (o *DcimConsolePortsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsPartialUpdateParams) SetID(id int64)

+ func (o *DcimConsolePortsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsPartialUpdateParams) WithContext(ctx context.Context) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) WithData(data *models.ConsolePort) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) WithID(id int64) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimConsolePortsPartialUpdateParams

+ func (o *DcimConsolePortsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsPartialUpdateReader struct

+ func (o *DcimConsolePortsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsReadOK struct

+ Payload *models.ConsolePort

+ func NewDcimConsolePortsReadOK() *DcimConsolePortsReadOK

+ func (o *DcimConsolePortsReadOK) Error() string

+ type DcimConsolePortsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortsReadParams() *DcimConsolePortsReadParams

+ func NewDcimConsolePortsReadParamsWithContext(ctx context.Context) *DcimConsolePortsReadParams

+ func NewDcimConsolePortsReadParamsWithHTTPClient(client *http.Client) *DcimConsolePortsReadParams

+ func NewDcimConsolePortsReadParamsWithTimeout(timeout time.Duration) *DcimConsolePortsReadParams

+ func (o *DcimConsolePortsReadParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsReadParams) SetID(id int64)

+ func (o *DcimConsolePortsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsReadParams) WithContext(ctx context.Context) *DcimConsolePortsReadParams

+ func (o *DcimConsolePortsReadParams) WithHTTPClient(client *http.Client) *DcimConsolePortsReadParams

+ func (o *DcimConsolePortsReadParams) WithID(id int64) *DcimConsolePortsReadParams

+ func (o *DcimConsolePortsReadParams) WithTimeout(timeout time.Duration) *DcimConsolePortsReadParams

+ func (o *DcimConsolePortsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsReadReader struct

+ func (o *DcimConsolePortsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsolePortsUpdateOK struct

+ Payload *models.ConsolePort

+ func NewDcimConsolePortsUpdateOK() *DcimConsolePortsUpdateOK

+ func (o *DcimConsolePortsUpdateOK) Error() string

+ type DcimConsolePortsUpdateParams struct

+ Context context.Context

+ Data *models.ConsolePort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsolePortsUpdateParams() *DcimConsolePortsUpdateParams

+ func NewDcimConsolePortsUpdateParamsWithContext(ctx context.Context) *DcimConsolePortsUpdateParams

+ func NewDcimConsolePortsUpdateParamsWithHTTPClient(client *http.Client) *DcimConsolePortsUpdateParams

+ func NewDcimConsolePortsUpdateParamsWithTimeout(timeout time.Duration) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsolePortsUpdateParams) SetData(data *models.ConsolePort)

+ func (o *DcimConsolePortsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsolePortsUpdateParams) SetID(id int64)

+ func (o *DcimConsolePortsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsolePortsUpdateParams) WithContext(ctx context.Context) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) WithData(data *models.ConsolePort) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) WithHTTPClient(client *http.Client) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) WithID(id int64) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) WithTimeout(timeout time.Duration) *DcimConsolePortsUpdateParams

+ func (o *DcimConsolePortsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsolePortsUpdateReader struct

+ func (o *DcimConsolePortsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesCreateCreated struct

+ Payload *models.ConsoleServerPortTemplate

+ func NewDcimConsoleServerPortTemplatesCreateCreated() *DcimConsoleServerPortTemplatesCreateCreated

+ func (o *DcimConsoleServerPortTemplatesCreateCreated) Error() string

+ type DcimConsoleServerPortTemplatesCreateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPortTemplate

+ HTTPClient *http.Client

+ func NewDcimConsoleServerPortTemplatesCreateParams() *DcimConsoleServerPortTemplatesCreateParams

+ func NewDcimConsoleServerPortTemplatesCreateParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesCreateParams

+ func NewDcimConsoleServerPortTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesCreateParams

+ func NewDcimConsoleServerPortTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesCreateParams

+ func (o *DcimConsoleServerPortTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesCreateParams) SetData(data *models.ConsoleServerPortTemplate)

+ func (o *DcimConsoleServerPortTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesCreateParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesCreateParams

+ func (o *DcimConsoleServerPortTemplatesCreateParams) WithData(data *models.ConsoleServerPortTemplate) *DcimConsoleServerPortTemplatesCreateParams

+ func (o *DcimConsoleServerPortTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesCreateParams

+ func (o *DcimConsoleServerPortTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesCreateParams

+ func (o *DcimConsoleServerPortTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesCreateReader struct

+ func (o *DcimConsoleServerPortTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesDeleteNoContent struct

+ func NewDcimConsoleServerPortTemplatesDeleteNoContent() *DcimConsoleServerPortTemplatesDeleteNoContent

+ func (o *DcimConsoleServerPortTemplatesDeleteNoContent) Error() string

+ type DcimConsoleServerPortTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortTemplatesDeleteParams() *DcimConsoleServerPortTemplatesDeleteParams

+ func NewDcimConsoleServerPortTemplatesDeleteParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesDeleteParams

+ func NewDcimConsoleServerPortTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesDeleteParams

+ func NewDcimConsoleServerPortTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesDeleteParams

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesDeleteParams

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesDeleteParams

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) WithID(id int64) *DcimConsoleServerPortTemplatesDeleteParams

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesDeleteParams

+ func (o *DcimConsoleServerPortTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesDeleteReader struct

+ func (o *DcimConsoleServerPortTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesListOK struct

+ Payload *DcimConsoleServerPortTemplatesListOKBody

+ func NewDcimConsoleServerPortTemplatesListOK() *DcimConsoleServerPortTemplatesListOK

+ func (o *DcimConsoleServerPortTemplatesListOK) Error() string

+ type DcimConsoleServerPortTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConsoleServerPortTemplate

+ func (o *DcimConsoleServerPortTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimConsoleServerPortTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimConsoleServerPortTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewDcimConsoleServerPortTemplatesListParams() *DcimConsoleServerPortTemplatesListParams

+ func NewDcimConsoleServerPortTemplatesListParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesListParams

+ func NewDcimConsoleServerPortTemplatesListParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesListParams

+ func NewDcimConsoleServerPortTemplatesListParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetName(name *string)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimConsoleServerPortTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesListParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithLimit(limit *int64) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithName(name *string) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithOffset(offset *int64) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesListParams

+ func (o *DcimConsoleServerPortTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesListReader struct

+ func (o *DcimConsoleServerPortTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesPartialUpdateOK struct

+ Payload *models.ConsoleServerPortTemplate

+ func NewDcimConsoleServerPortTemplatesPartialUpdateOK() *DcimConsoleServerPortTemplatesPartialUpdateOK

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateOK) Error() string

+ type DcimConsoleServerPortTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortTemplatesPartialUpdateParams() *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func NewDcimConsoleServerPortTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func NewDcimConsoleServerPortTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func NewDcimConsoleServerPortTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) SetData(data *models.ConsoleServerPortTemplate)

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WithData(data *models.ConsoleServerPortTemplate) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WithID(id int64) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesPartialUpdateParams

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesPartialUpdateReader struct

+ func (o *DcimConsoleServerPortTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesReadOK struct

+ Payload *models.ConsoleServerPortTemplate

+ func NewDcimConsoleServerPortTemplatesReadOK() *DcimConsoleServerPortTemplatesReadOK

+ func (o *DcimConsoleServerPortTemplatesReadOK) Error() string

+ type DcimConsoleServerPortTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortTemplatesReadParams() *DcimConsoleServerPortTemplatesReadParams

+ func NewDcimConsoleServerPortTemplatesReadParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesReadParams

+ func NewDcimConsoleServerPortTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesReadParams

+ func NewDcimConsoleServerPortTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesReadParams

+ func (o *DcimConsoleServerPortTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesReadParams) SetID(id int64)

+ func (o *DcimConsoleServerPortTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesReadParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesReadParams

+ func (o *DcimConsoleServerPortTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesReadParams

+ func (o *DcimConsoleServerPortTemplatesReadParams) WithID(id int64) *DcimConsoleServerPortTemplatesReadParams

+ func (o *DcimConsoleServerPortTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesReadParams

+ func (o *DcimConsoleServerPortTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesReadReader struct

+ func (o *DcimConsoleServerPortTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortTemplatesUpdateOK struct

+ Payload *models.ConsoleServerPortTemplate

+ func NewDcimConsoleServerPortTemplatesUpdateOK() *DcimConsoleServerPortTemplatesUpdateOK

+ func (o *DcimConsoleServerPortTemplatesUpdateOK) Error() string

+ type DcimConsoleServerPortTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortTemplatesUpdateParams() *DcimConsoleServerPortTemplatesUpdateParams

+ func NewDcimConsoleServerPortTemplatesUpdateParamsWithContext(ctx context.Context) *DcimConsoleServerPortTemplatesUpdateParams

+ func NewDcimConsoleServerPortTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesUpdateParams

+ func NewDcimConsoleServerPortTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) SetData(data *models.ConsoleServerPortTemplate)

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WithContext(ctx context.Context) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WithData(data *models.ConsoleServerPortTemplate) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WithID(id int64) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortTemplatesUpdateParams

+ func (o *DcimConsoleServerPortTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortTemplatesUpdateReader struct

+ func (o *DcimConsoleServerPortTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsCreateCreated struct

+ Payload *models.ConsoleServerPort

+ func NewDcimConsoleServerPortsCreateCreated() *DcimConsoleServerPortsCreateCreated

+ func (o *DcimConsoleServerPortsCreateCreated) Error() string

+ type DcimConsoleServerPortsCreateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPort

+ HTTPClient *http.Client

+ func NewDcimConsoleServerPortsCreateParams() *DcimConsoleServerPortsCreateParams

+ func NewDcimConsoleServerPortsCreateParamsWithContext(ctx context.Context) *DcimConsoleServerPortsCreateParams

+ func NewDcimConsoleServerPortsCreateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsCreateParams

+ func NewDcimConsoleServerPortsCreateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsCreateParams

+ func (o *DcimConsoleServerPortsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsCreateParams) SetData(data *models.ConsoleServerPort)

+ func (o *DcimConsoleServerPortsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsCreateParams) WithContext(ctx context.Context) *DcimConsoleServerPortsCreateParams

+ func (o *DcimConsoleServerPortsCreateParams) WithData(data *models.ConsoleServerPort) *DcimConsoleServerPortsCreateParams

+ func (o *DcimConsoleServerPortsCreateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsCreateParams

+ func (o *DcimConsoleServerPortsCreateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsCreateParams

+ func (o *DcimConsoleServerPortsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsCreateReader struct

+ func (o *DcimConsoleServerPortsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsDeleteNoContent struct

+ func NewDcimConsoleServerPortsDeleteNoContent() *DcimConsoleServerPortsDeleteNoContent

+ func (o *DcimConsoleServerPortsDeleteNoContent) Error() string

+ type DcimConsoleServerPortsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortsDeleteParams() *DcimConsoleServerPortsDeleteParams

+ func NewDcimConsoleServerPortsDeleteParamsWithContext(ctx context.Context) *DcimConsoleServerPortsDeleteParams

+ func NewDcimConsoleServerPortsDeleteParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsDeleteParams

+ func NewDcimConsoleServerPortsDeleteParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsDeleteParams

+ func (o *DcimConsoleServerPortsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsDeleteParams) SetID(id int64)

+ func (o *DcimConsoleServerPortsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsDeleteParams) WithContext(ctx context.Context) *DcimConsoleServerPortsDeleteParams

+ func (o *DcimConsoleServerPortsDeleteParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsDeleteParams

+ func (o *DcimConsoleServerPortsDeleteParams) WithID(id int64) *DcimConsoleServerPortsDeleteParams

+ func (o *DcimConsoleServerPortsDeleteParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsDeleteParams

+ func (o *DcimConsoleServerPortsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsDeleteReader struct

+ func (o *DcimConsoleServerPortsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsListOK struct

+ Payload *DcimConsoleServerPortsListOKBody

+ func NewDcimConsoleServerPortsListOK() *DcimConsoleServerPortsListOK

+ func (o *DcimConsoleServerPortsListOK) Error() string

+ type DcimConsoleServerPortsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.ConsoleServerPort

+ func (o *DcimConsoleServerPortsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimConsoleServerPortsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimConsoleServerPortsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimConsoleServerPortsListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Tag *string

+ func NewDcimConsoleServerPortsListParams() *DcimConsoleServerPortsListParams

+ func NewDcimConsoleServerPortsListParamsWithContext(ctx context.Context) *DcimConsoleServerPortsListParams

+ func NewDcimConsoleServerPortsListParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsListParams

+ func NewDcimConsoleServerPortsListParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsListParams) SetDevice(device *string)

+ func (o *DcimConsoleServerPortsListParams) SetDeviceID(deviceID *string)

+ func (o *DcimConsoleServerPortsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsListParams) SetLimit(limit *int64)

+ func (o *DcimConsoleServerPortsListParams) SetName(name *string)

+ func (o *DcimConsoleServerPortsListParams) SetOffset(offset *int64)

+ func (o *DcimConsoleServerPortsListParams) SetTag(tag *string)

+ func (o *DcimConsoleServerPortsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsListParams) WithContext(ctx context.Context) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithDevice(device *string) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithDeviceID(deviceID *string) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithLimit(limit *int64) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithName(name *string) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithOffset(offset *int64) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithTag(tag *string) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsListParams

+ func (o *DcimConsoleServerPortsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsListReader struct

+ func (o *DcimConsoleServerPortsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsPartialUpdateOK struct

+ Payload *models.ConsoleServerPort

+ func NewDcimConsoleServerPortsPartialUpdateOK() *DcimConsoleServerPortsPartialUpdateOK

+ func (o *DcimConsoleServerPortsPartialUpdateOK) Error() string

+ type DcimConsoleServerPortsPartialUpdateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortsPartialUpdateParams() *DcimConsoleServerPortsPartialUpdateParams

+ func NewDcimConsoleServerPortsPartialUpdateParamsWithContext(ctx context.Context) *DcimConsoleServerPortsPartialUpdateParams

+ func NewDcimConsoleServerPortsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsPartialUpdateParams

+ func NewDcimConsoleServerPortsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsPartialUpdateParams) SetData(data *models.ConsoleServerPort)

+ func (o *DcimConsoleServerPortsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsPartialUpdateParams) SetID(id int64)

+ func (o *DcimConsoleServerPortsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WithContext(ctx context.Context) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WithData(data *models.ConsoleServerPort) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WithID(id int64) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsPartialUpdateParams

+ func (o *DcimConsoleServerPortsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsPartialUpdateReader struct

+ func (o *DcimConsoleServerPortsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsReadOK struct

+ Payload *models.ConsoleServerPort

+ func NewDcimConsoleServerPortsReadOK() *DcimConsoleServerPortsReadOK

+ func (o *DcimConsoleServerPortsReadOK) Error() string

+ type DcimConsoleServerPortsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortsReadParams() *DcimConsoleServerPortsReadParams

+ func NewDcimConsoleServerPortsReadParamsWithContext(ctx context.Context) *DcimConsoleServerPortsReadParams

+ func NewDcimConsoleServerPortsReadParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsReadParams

+ func NewDcimConsoleServerPortsReadParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsReadParams

+ func (o *DcimConsoleServerPortsReadParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsReadParams) SetID(id int64)

+ func (o *DcimConsoleServerPortsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsReadParams) WithContext(ctx context.Context) *DcimConsoleServerPortsReadParams

+ func (o *DcimConsoleServerPortsReadParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsReadParams

+ func (o *DcimConsoleServerPortsReadParams) WithID(id int64) *DcimConsoleServerPortsReadParams

+ func (o *DcimConsoleServerPortsReadParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsReadParams

+ func (o *DcimConsoleServerPortsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsReadReader struct

+ func (o *DcimConsoleServerPortsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimConsoleServerPortsUpdateOK struct

+ Payload *models.ConsoleServerPort

+ func NewDcimConsoleServerPortsUpdateOK() *DcimConsoleServerPortsUpdateOK

+ func (o *DcimConsoleServerPortsUpdateOK) Error() string

+ type DcimConsoleServerPortsUpdateParams struct

+ Context context.Context

+ Data *models.ConsoleServerPort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimConsoleServerPortsUpdateParams() *DcimConsoleServerPortsUpdateParams

+ func NewDcimConsoleServerPortsUpdateParamsWithContext(ctx context.Context) *DcimConsoleServerPortsUpdateParams

+ func NewDcimConsoleServerPortsUpdateParamsWithHTTPClient(client *http.Client) *DcimConsoleServerPortsUpdateParams

+ func NewDcimConsoleServerPortsUpdateParamsWithTimeout(timeout time.Duration) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimConsoleServerPortsUpdateParams) SetData(data *models.ConsoleServerPort)

+ func (o *DcimConsoleServerPortsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimConsoleServerPortsUpdateParams) SetID(id int64)

+ func (o *DcimConsoleServerPortsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimConsoleServerPortsUpdateParams) WithContext(ctx context.Context) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) WithData(data *models.ConsoleServerPort) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) WithHTTPClient(client *http.Client) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) WithID(id int64) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) WithTimeout(timeout time.Duration) *DcimConsoleServerPortsUpdateParams

+ func (o *DcimConsoleServerPortsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimConsoleServerPortsUpdateReader struct

+ func (o *DcimConsoleServerPortsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesCreateCreated struct

+ Payload *models.DeviceBayTemplate

+ func NewDcimDeviceBayTemplatesCreateCreated() *DcimDeviceBayTemplatesCreateCreated

+ func (o *DcimDeviceBayTemplatesCreateCreated) Error() string

+ type DcimDeviceBayTemplatesCreateParams struct

+ Context context.Context

+ Data *models.DeviceBayTemplate

+ HTTPClient *http.Client

+ func NewDcimDeviceBayTemplatesCreateParams() *DcimDeviceBayTemplatesCreateParams

+ func NewDcimDeviceBayTemplatesCreateParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesCreateParams

+ func NewDcimDeviceBayTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesCreateParams

+ func NewDcimDeviceBayTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesCreateParams

+ func (o *DcimDeviceBayTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesCreateParams) SetData(data *models.DeviceBayTemplate)

+ func (o *DcimDeviceBayTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesCreateParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesCreateParams

+ func (o *DcimDeviceBayTemplatesCreateParams) WithData(data *models.DeviceBayTemplate) *DcimDeviceBayTemplatesCreateParams

+ func (o *DcimDeviceBayTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesCreateParams

+ func (o *DcimDeviceBayTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesCreateParams

+ func (o *DcimDeviceBayTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesCreateReader struct

+ func (o *DcimDeviceBayTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesDeleteNoContent struct

+ func NewDcimDeviceBayTemplatesDeleteNoContent() *DcimDeviceBayTemplatesDeleteNoContent

+ func (o *DcimDeviceBayTemplatesDeleteNoContent) Error() string

+ type DcimDeviceBayTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBayTemplatesDeleteParams() *DcimDeviceBayTemplatesDeleteParams

+ func NewDcimDeviceBayTemplatesDeleteParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesDeleteParams

+ func NewDcimDeviceBayTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesDeleteParams

+ func NewDcimDeviceBayTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesDeleteParams

+ func (o *DcimDeviceBayTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimDeviceBayTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesDeleteParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesDeleteParams

+ func (o *DcimDeviceBayTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesDeleteParams

+ func (o *DcimDeviceBayTemplatesDeleteParams) WithID(id int64) *DcimDeviceBayTemplatesDeleteParams

+ func (o *DcimDeviceBayTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesDeleteParams

+ func (o *DcimDeviceBayTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesDeleteReader struct

+ func (o *DcimDeviceBayTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesListOK struct

+ Payload *DcimDeviceBayTemplatesListOKBody

+ func NewDcimDeviceBayTemplatesListOK() *DcimDeviceBayTemplatesListOK

+ func (o *DcimDeviceBayTemplatesListOK) Error() string

+ type DcimDeviceBayTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.DeviceBayTemplate

+ func (o *DcimDeviceBayTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimDeviceBayTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimDeviceBayTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimDeviceBayTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewDcimDeviceBayTemplatesListParams() *DcimDeviceBayTemplatesListParams

+ func NewDcimDeviceBayTemplatesListParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesListParams

+ func NewDcimDeviceBayTemplatesListParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesListParams

+ func NewDcimDeviceBayTemplatesListParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimDeviceBayTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimDeviceBayTemplatesListParams) SetName(name *string)

+ func (o *DcimDeviceBayTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimDeviceBayTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesListParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithLimit(limit *int64) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithName(name *string) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithOffset(offset *int64) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesListParams

+ func (o *DcimDeviceBayTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesListReader struct

+ func (o *DcimDeviceBayTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesPartialUpdateOK struct

+ Payload *models.DeviceBayTemplate

+ func NewDcimDeviceBayTemplatesPartialUpdateOK() *DcimDeviceBayTemplatesPartialUpdateOK

+ func (o *DcimDeviceBayTemplatesPartialUpdateOK) Error() string

+ type DcimDeviceBayTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.DeviceBayTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBayTemplatesPartialUpdateParams() *DcimDeviceBayTemplatesPartialUpdateParams

+ func NewDcimDeviceBayTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesPartialUpdateParams

+ func NewDcimDeviceBayTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesPartialUpdateParams

+ func NewDcimDeviceBayTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) SetData(data *models.DeviceBayTemplate)

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WithData(data *models.DeviceBayTemplate) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WithID(id int64) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesPartialUpdateParams

+ func (o *DcimDeviceBayTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesPartialUpdateReader struct

+ func (o *DcimDeviceBayTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesReadOK struct

+ Payload *models.DeviceBayTemplate

+ func NewDcimDeviceBayTemplatesReadOK() *DcimDeviceBayTemplatesReadOK

+ func (o *DcimDeviceBayTemplatesReadOK) Error() string

+ type DcimDeviceBayTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBayTemplatesReadParams() *DcimDeviceBayTemplatesReadParams

+ func NewDcimDeviceBayTemplatesReadParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesReadParams

+ func NewDcimDeviceBayTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesReadParams

+ func NewDcimDeviceBayTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesReadParams

+ func (o *DcimDeviceBayTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesReadParams) SetID(id int64)

+ func (o *DcimDeviceBayTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesReadParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesReadParams

+ func (o *DcimDeviceBayTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesReadParams

+ func (o *DcimDeviceBayTemplatesReadParams) WithID(id int64) *DcimDeviceBayTemplatesReadParams

+ func (o *DcimDeviceBayTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesReadParams

+ func (o *DcimDeviceBayTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesReadReader struct

+ func (o *DcimDeviceBayTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBayTemplatesUpdateOK struct

+ Payload *models.DeviceBayTemplate

+ func NewDcimDeviceBayTemplatesUpdateOK() *DcimDeviceBayTemplatesUpdateOK

+ func (o *DcimDeviceBayTemplatesUpdateOK) Error() string

+ type DcimDeviceBayTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.DeviceBayTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBayTemplatesUpdateParams() *DcimDeviceBayTemplatesUpdateParams

+ func NewDcimDeviceBayTemplatesUpdateParamsWithContext(ctx context.Context) *DcimDeviceBayTemplatesUpdateParams

+ func NewDcimDeviceBayTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesUpdateParams

+ func NewDcimDeviceBayTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBayTemplatesUpdateParams) SetData(data *models.DeviceBayTemplate)

+ func (o *DcimDeviceBayTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBayTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimDeviceBayTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBayTemplatesUpdateParams) WithContext(ctx context.Context) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) WithData(data *models.DeviceBayTemplate) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) WithID(id int64) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceBayTemplatesUpdateParams

+ func (o *DcimDeviceBayTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBayTemplatesUpdateReader struct

+ func (o *DcimDeviceBayTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysCreateCreated struct

+ Payload *models.DeviceBay

+ func NewDcimDeviceBaysCreateCreated() *DcimDeviceBaysCreateCreated

+ func (o *DcimDeviceBaysCreateCreated) Error() string

+ type DcimDeviceBaysCreateParams struct

+ Context context.Context

+ Data *models.DeviceBay

+ HTTPClient *http.Client

+ func NewDcimDeviceBaysCreateParams() *DcimDeviceBaysCreateParams

+ func NewDcimDeviceBaysCreateParamsWithContext(ctx context.Context) *DcimDeviceBaysCreateParams

+ func NewDcimDeviceBaysCreateParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysCreateParams

+ func NewDcimDeviceBaysCreateParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysCreateParams

+ func (o *DcimDeviceBaysCreateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysCreateParams) SetData(data *models.DeviceBay)

+ func (o *DcimDeviceBaysCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysCreateParams) WithContext(ctx context.Context) *DcimDeviceBaysCreateParams

+ func (o *DcimDeviceBaysCreateParams) WithData(data *models.DeviceBay) *DcimDeviceBaysCreateParams

+ func (o *DcimDeviceBaysCreateParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysCreateParams

+ func (o *DcimDeviceBaysCreateParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysCreateParams

+ func (o *DcimDeviceBaysCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysCreateReader struct

+ func (o *DcimDeviceBaysCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysDeleteNoContent struct

+ func NewDcimDeviceBaysDeleteNoContent() *DcimDeviceBaysDeleteNoContent

+ func (o *DcimDeviceBaysDeleteNoContent) Error() string

+ type DcimDeviceBaysDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBaysDeleteParams() *DcimDeviceBaysDeleteParams

+ func NewDcimDeviceBaysDeleteParamsWithContext(ctx context.Context) *DcimDeviceBaysDeleteParams

+ func NewDcimDeviceBaysDeleteParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysDeleteParams

+ func NewDcimDeviceBaysDeleteParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysDeleteParams

+ func (o *DcimDeviceBaysDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysDeleteParams) SetID(id int64)

+ func (o *DcimDeviceBaysDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysDeleteParams) WithContext(ctx context.Context) *DcimDeviceBaysDeleteParams

+ func (o *DcimDeviceBaysDeleteParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysDeleteParams

+ func (o *DcimDeviceBaysDeleteParams) WithID(id int64) *DcimDeviceBaysDeleteParams

+ func (o *DcimDeviceBaysDeleteParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysDeleteParams

+ func (o *DcimDeviceBaysDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysDeleteReader struct

+ func (o *DcimDeviceBaysDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysListOK struct

+ Payload *DcimDeviceBaysListOKBody

+ func NewDcimDeviceBaysListOK() *DcimDeviceBaysListOK

+ func (o *DcimDeviceBaysListOK) Error() string

+ type DcimDeviceBaysListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.DeviceBay

+ func (o *DcimDeviceBaysListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimDeviceBaysListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimDeviceBaysListOKBody) Validate(formats strfmt.Registry) error

+ type DcimDeviceBaysListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Tag *string

+ func NewDcimDeviceBaysListParams() *DcimDeviceBaysListParams

+ func NewDcimDeviceBaysListParamsWithContext(ctx context.Context) *DcimDeviceBaysListParams

+ func NewDcimDeviceBaysListParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysListParams

+ func NewDcimDeviceBaysListParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysListParams) SetDevice(device *string)

+ func (o *DcimDeviceBaysListParams) SetDeviceID(deviceID *string)

+ func (o *DcimDeviceBaysListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysListParams) SetLimit(limit *int64)

+ func (o *DcimDeviceBaysListParams) SetName(name *string)

+ func (o *DcimDeviceBaysListParams) SetOffset(offset *int64)

+ func (o *DcimDeviceBaysListParams) SetTag(tag *string)

+ func (o *DcimDeviceBaysListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysListParams) WithContext(ctx context.Context) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithDevice(device *string) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithDeviceID(deviceID *string) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithLimit(limit *int64) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithName(name *string) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithOffset(offset *int64) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithTag(tag *string) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysListParams

+ func (o *DcimDeviceBaysListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysListReader struct

+ func (o *DcimDeviceBaysListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysPartialUpdateOK struct

+ Payload *models.DeviceBay

+ func NewDcimDeviceBaysPartialUpdateOK() *DcimDeviceBaysPartialUpdateOK

+ func (o *DcimDeviceBaysPartialUpdateOK) Error() string

+ type DcimDeviceBaysPartialUpdateParams struct

+ Context context.Context

+ Data *models.DeviceBay

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBaysPartialUpdateParams() *DcimDeviceBaysPartialUpdateParams

+ func NewDcimDeviceBaysPartialUpdateParamsWithContext(ctx context.Context) *DcimDeviceBaysPartialUpdateParams

+ func NewDcimDeviceBaysPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysPartialUpdateParams

+ func NewDcimDeviceBaysPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysPartialUpdateParams) SetData(data *models.DeviceBay)

+ func (o *DcimDeviceBaysPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysPartialUpdateParams) SetID(id int64)

+ func (o *DcimDeviceBaysPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysPartialUpdateParams) WithContext(ctx context.Context) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) WithData(data *models.DeviceBay) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) WithID(id int64) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysPartialUpdateParams

+ func (o *DcimDeviceBaysPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysPartialUpdateReader struct

+ func (o *DcimDeviceBaysPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysReadOK struct

+ Payload *models.DeviceBay

+ func NewDcimDeviceBaysReadOK() *DcimDeviceBaysReadOK

+ func (o *DcimDeviceBaysReadOK) Error() string

+ type DcimDeviceBaysReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBaysReadParams() *DcimDeviceBaysReadParams

+ func NewDcimDeviceBaysReadParamsWithContext(ctx context.Context) *DcimDeviceBaysReadParams

+ func NewDcimDeviceBaysReadParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysReadParams

+ func NewDcimDeviceBaysReadParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysReadParams

+ func (o *DcimDeviceBaysReadParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysReadParams) SetID(id int64)

+ func (o *DcimDeviceBaysReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysReadParams) WithContext(ctx context.Context) *DcimDeviceBaysReadParams

+ func (o *DcimDeviceBaysReadParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysReadParams

+ func (o *DcimDeviceBaysReadParams) WithID(id int64) *DcimDeviceBaysReadParams

+ func (o *DcimDeviceBaysReadParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysReadParams

+ func (o *DcimDeviceBaysReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysReadReader struct

+ func (o *DcimDeviceBaysReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceBaysUpdateOK struct

+ Payload *models.DeviceBay

+ func NewDcimDeviceBaysUpdateOK() *DcimDeviceBaysUpdateOK

+ func (o *DcimDeviceBaysUpdateOK) Error() string

+ type DcimDeviceBaysUpdateParams struct

+ Context context.Context

+ Data *models.DeviceBay

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceBaysUpdateParams() *DcimDeviceBaysUpdateParams

+ func NewDcimDeviceBaysUpdateParamsWithContext(ctx context.Context) *DcimDeviceBaysUpdateParams

+ func NewDcimDeviceBaysUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceBaysUpdateParams

+ func NewDcimDeviceBaysUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceBaysUpdateParams) SetData(data *models.DeviceBay)

+ func (o *DcimDeviceBaysUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceBaysUpdateParams) SetID(id int64)

+ func (o *DcimDeviceBaysUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceBaysUpdateParams) WithContext(ctx context.Context) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) WithData(data *models.DeviceBay) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) WithID(id int64) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceBaysUpdateParams

+ func (o *DcimDeviceBaysUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceBaysUpdateReader struct

+ func (o *DcimDeviceBaysUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesCreateCreated struct

+ Payload *models.DeviceRole

+ func NewDcimDeviceRolesCreateCreated() *DcimDeviceRolesCreateCreated

+ func (o *DcimDeviceRolesCreateCreated) Error() string

+ type DcimDeviceRolesCreateParams struct

+ Context context.Context

+ Data *models.DeviceRole

+ HTTPClient *http.Client

+ func NewDcimDeviceRolesCreateParams() *DcimDeviceRolesCreateParams

+ func NewDcimDeviceRolesCreateParamsWithContext(ctx context.Context) *DcimDeviceRolesCreateParams

+ func NewDcimDeviceRolesCreateParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesCreateParams

+ func NewDcimDeviceRolesCreateParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesCreateParams

+ func (o *DcimDeviceRolesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesCreateParams) SetData(data *models.DeviceRole)

+ func (o *DcimDeviceRolesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesCreateParams) WithContext(ctx context.Context) *DcimDeviceRolesCreateParams

+ func (o *DcimDeviceRolesCreateParams) WithData(data *models.DeviceRole) *DcimDeviceRolesCreateParams

+ func (o *DcimDeviceRolesCreateParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesCreateParams

+ func (o *DcimDeviceRolesCreateParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesCreateParams

+ func (o *DcimDeviceRolesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesCreateReader struct

+ func (o *DcimDeviceRolesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesDeleteNoContent struct

+ func NewDcimDeviceRolesDeleteNoContent() *DcimDeviceRolesDeleteNoContent

+ func (o *DcimDeviceRolesDeleteNoContent) Error() string

+ type DcimDeviceRolesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceRolesDeleteParams() *DcimDeviceRolesDeleteParams

+ func NewDcimDeviceRolesDeleteParamsWithContext(ctx context.Context) *DcimDeviceRolesDeleteParams

+ func NewDcimDeviceRolesDeleteParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesDeleteParams

+ func NewDcimDeviceRolesDeleteParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesDeleteParams

+ func (o *DcimDeviceRolesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesDeleteParams) SetID(id int64)

+ func (o *DcimDeviceRolesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesDeleteParams) WithContext(ctx context.Context) *DcimDeviceRolesDeleteParams

+ func (o *DcimDeviceRolesDeleteParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesDeleteParams

+ func (o *DcimDeviceRolesDeleteParams) WithID(id int64) *DcimDeviceRolesDeleteParams

+ func (o *DcimDeviceRolesDeleteParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesDeleteParams

+ func (o *DcimDeviceRolesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesDeleteReader struct

+ func (o *DcimDeviceRolesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesListOK struct

+ Payload *DcimDeviceRolesListOKBody

+ func NewDcimDeviceRolesListOK() *DcimDeviceRolesListOK

+ func (o *DcimDeviceRolesListOK) Error() string

+ type DcimDeviceRolesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.DeviceRole

+ func (o *DcimDeviceRolesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimDeviceRolesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimDeviceRolesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimDeviceRolesListParams struct

+ Color *string

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Slug *string

+ VMRole *string

+ func NewDcimDeviceRolesListParams() *DcimDeviceRolesListParams

+ func NewDcimDeviceRolesListParamsWithContext(ctx context.Context) *DcimDeviceRolesListParams

+ func NewDcimDeviceRolesListParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesListParams

+ func NewDcimDeviceRolesListParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) SetColor(color *string)

+ func (o *DcimDeviceRolesListParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesListParams) SetLimit(limit *int64)

+ func (o *DcimDeviceRolesListParams) SetName(name *string)

+ func (o *DcimDeviceRolesListParams) SetOffset(offset *int64)

+ func (o *DcimDeviceRolesListParams) SetSlug(slug *string)

+ func (o *DcimDeviceRolesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesListParams) SetVMRole(vMRole *string)

+ func (o *DcimDeviceRolesListParams) WithColor(color *string) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithContext(ctx context.Context) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithLimit(limit *int64) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithName(name *string) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithOffset(offset *int64) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithSlug(slug *string) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WithVMRole(vMRole *string) *DcimDeviceRolesListParams

+ func (o *DcimDeviceRolesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesListReader struct

+ func (o *DcimDeviceRolesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesPartialUpdateOK struct

+ Payload *models.DeviceRole

+ func NewDcimDeviceRolesPartialUpdateOK() *DcimDeviceRolesPartialUpdateOK

+ func (o *DcimDeviceRolesPartialUpdateOK) Error() string

+ type DcimDeviceRolesPartialUpdateParams struct

+ Context context.Context

+ Data *models.DeviceRole

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceRolesPartialUpdateParams() *DcimDeviceRolesPartialUpdateParams

+ func NewDcimDeviceRolesPartialUpdateParamsWithContext(ctx context.Context) *DcimDeviceRolesPartialUpdateParams

+ func NewDcimDeviceRolesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesPartialUpdateParams

+ func NewDcimDeviceRolesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesPartialUpdateParams) SetData(data *models.DeviceRole)

+ func (o *DcimDeviceRolesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesPartialUpdateParams) SetID(id int64)

+ func (o *DcimDeviceRolesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesPartialUpdateParams) WithContext(ctx context.Context) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) WithData(data *models.DeviceRole) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) WithID(id int64) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesPartialUpdateParams

+ func (o *DcimDeviceRolesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesPartialUpdateReader struct

+ func (o *DcimDeviceRolesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesReadOK struct

+ Payload *models.DeviceRole

+ func NewDcimDeviceRolesReadOK() *DcimDeviceRolesReadOK

+ func (o *DcimDeviceRolesReadOK) Error() string

+ type DcimDeviceRolesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceRolesReadParams() *DcimDeviceRolesReadParams

+ func NewDcimDeviceRolesReadParamsWithContext(ctx context.Context) *DcimDeviceRolesReadParams

+ func NewDcimDeviceRolesReadParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesReadParams

+ func NewDcimDeviceRolesReadParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesReadParams

+ func (o *DcimDeviceRolesReadParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesReadParams) SetID(id int64)

+ func (o *DcimDeviceRolesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesReadParams) WithContext(ctx context.Context) *DcimDeviceRolesReadParams

+ func (o *DcimDeviceRolesReadParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesReadParams

+ func (o *DcimDeviceRolesReadParams) WithID(id int64) *DcimDeviceRolesReadParams

+ func (o *DcimDeviceRolesReadParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesReadParams

+ func (o *DcimDeviceRolesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesReadReader struct

+ func (o *DcimDeviceRolesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceRolesUpdateOK struct

+ Payload *models.DeviceRole

+ func NewDcimDeviceRolesUpdateOK() *DcimDeviceRolesUpdateOK

+ func (o *DcimDeviceRolesUpdateOK) Error() string

+ type DcimDeviceRolesUpdateParams struct

+ Context context.Context

+ Data *models.DeviceRole

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceRolesUpdateParams() *DcimDeviceRolesUpdateParams

+ func NewDcimDeviceRolesUpdateParamsWithContext(ctx context.Context) *DcimDeviceRolesUpdateParams

+ func NewDcimDeviceRolesUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceRolesUpdateParams

+ func NewDcimDeviceRolesUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceRolesUpdateParams) SetData(data *models.DeviceRole)

+ func (o *DcimDeviceRolesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceRolesUpdateParams) SetID(id int64)

+ func (o *DcimDeviceRolesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceRolesUpdateParams) WithContext(ctx context.Context) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) WithData(data *models.DeviceRole) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) WithID(id int64) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceRolesUpdateParams

+ func (o *DcimDeviceRolesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceRolesUpdateReader struct

+ func (o *DcimDeviceRolesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesCreateCreated struct

+ Payload *models.DeviceType

+ func NewDcimDeviceTypesCreateCreated() *DcimDeviceTypesCreateCreated

+ func (o *DcimDeviceTypesCreateCreated) Error() string

+ type DcimDeviceTypesCreateParams struct

+ Context context.Context

+ Data *models.DeviceType

+ HTTPClient *http.Client

+ func NewDcimDeviceTypesCreateParams() *DcimDeviceTypesCreateParams

+ func NewDcimDeviceTypesCreateParamsWithContext(ctx context.Context) *DcimDeviceTypesCreateParams

+ func NewDcimDeviceTypesCreateParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesCreateParams

+ func NewDcimDeviceTypesCreateParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesCreateParams

+ func (o *DcimDeviceTypesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesCreateParams) SetData(data *models.DeviceType)

+ func (o *DcimDeviceTypesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesCreateParams) WithContext(ctx context.Context) *DcimDeviceTypesCreateParams

+ func (o *DcimDeviceTypesCreateParams) WithData(data *models.DeviceType) *DcimDeviceTypesCreateParams

+ func (o *DcimDeviceTypesCreateParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesCreateParams

+ func (o *DcimDeviceTypesCreateParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesCreateParams

+ func (o *DcimDeviceTypesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesCreateReader struct

+ func (o *DcimDeviceTypesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesDeleteNoContent struct

+ func NewDcimDeviceTypesDeleteNoContent() *DcimDeviceTypesDeleteNoContent

+ func (o *DcimDeviceTypesDeleteNoContent) Error() string

+ type DcimDeviceTypesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceTypesDeleteParams() *DcimDeviceTypesDeleteParams

+ func NewDcimDeviceTypesDeleteParamsWithContext(ctx context.Context) *DcimDeviceTypesDeleteParams

+ func NewDcimDeviceTypesDeleteParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesDeleteParams

+ func NewDcimDeviceTypesDeleteParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesDeleteParams

+ func (o *DcimDeviceTypesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesDeleteParams) SetID(id int64)

+ func (o *DcimDeviceTypesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesDeleteParams) WithContext(ctx context.Context) *DcimDeviceTypesDeleteParams

+ func (o *DcimDeviceTypesDeleteParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesDeleteParams

+ func (o *DcimDeviceTypesDeleteParams) WithID(id int64) *DcimDeviceTypesDeleteParams

+ func (o *DcimDeviceTypesDeleteParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesDeleteParams

+ func (o *DcimDeviceTypesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesDeleteReader struct

+ func (o *DcimDeviceTypesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesListOK struct

+ Payload *DcimDeviceTypesListOKBody

+ func NewDcimDeviceTypesListOK() *DcimDeviceTypesListOK

+ func (o *DcimDeviceTypesListOK) Error() string

+ type DcimDeviceTypesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.DeviceType

+ func (o *DcimDeviceTypesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimDeviceTypesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimDeviceTypesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimDeviceTypesListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ IDIn *string

+ IsConsoleServer *string

+ IsFullDepth *string

+ IsNetworkDevice *string

+ IsPdu *string

+ Limit *int64

+ Manufacturer *string

+ ManufacturerID *string

+ Model *string

+ Offset *int64

+ PartNumber *string

+ Q *string

+ Slug *string

+ SubdeviceRole *string

+ Tag *string

+ UHeight *float64

+ func NewDcimDeviceTypesListParams() *DcimDeviceTypesListParams

+ func NewDcimDeviceTypesListParamsWithContext(ctx context.Context) *DcimDeviceTypesListParams

+ func NewDcimDeviceTypesListParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesListParams

+ func NewDcimDeviceTypesListParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesListParams) SetIDIn(iDIn *string)

+ func (o *DcimDeviceTypesListParams) SetIsConsoleServer(isConsoleServer *string)

+ func (o *DcimDeviceTypesListParams) SetIsFullDepth(isFullDepth *string)

+ func (o *DcimDeviceTypesListParams) SetIsNetworkDevice(isNetworkDevice *string)

+ func (o *DcimDeviceTypesListParams) SetIsPdu(isPdu *string)

+ func (o *DcimDeviceTypesListParams) SetLimit(limit *int64)

+ func (o *DcimDeviceTypesListParams) SetManufacturer(manufacturer *string)

+ func (o *DcimDeviceTypesListParams) SetManufacturerID(manufacturerID *string)

+ func (o *DcimDeviceTypesListParams) SetModel(model *string)

+ func (o *DcimDeviceTypesListParams) SetOffset(offset *int64)

+ func (o *DcimDeviceTypesListParams) SetPartNumber(partNumber *string)

+ func (o *DcimDeviceTypesListParams) SetQ(q *string)

+ func (o *DcimDeviceTypesListParams) SetSlug(slug *string)

+ func (o *DcimDeviceTypesListParams) SetSubdeviceRole(subdeviceRole *string)

+ func (o *DcimDeviceTypesListParams) SetTag(tag *string)

+ func (o *DcimDeviceTypesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesListParams) SetUHeight(uHeight *float64)

+ func (o *DcimDeviceTypesListParams) WithContext(ctx context.Context) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithIDIn(iDIn *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithIsConsoleServer(isConsoleServer *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithIsFullDepth(isFullDepth *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithIsNetworkDevice(isNetworkDevice *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithIsPdu(isPdu *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithLimit(limit *int64) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithManufacturer(manufacturer *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithManufacturerID(manufacturerID *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithModel(model *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithOffset(offset *int64) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithPartNumber(partNumber *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithQ(q *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithSlug(slug *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithSubdeviceRole(subdeviceRole *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithTag(tag *string) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WithUHeight(uHeight *float64) *DcimDeviceTypesListParams

+ func (o *DcimDeviceTypesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesListReader struct

+ func (o *DcimDeviceTypesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesPartialUpdateOK struct

+ Payload *models.DeviceType

+ func NewDcimDeviceTypesPartialUpdateOK() *DcimDeviceTypesPartialUpdateOK

+ func (o *DcimDeviceTypesPartialUpdateOK) Error() string

+ type DcimDeviceTypesPartialUpdateParams struct

+ Context context.Context

+ Data *models.DeviceType

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceTypesPartialUpdateParams() *DcimDeviceTypesPartialUpdateParams

+ func NewDcimDeviceTypesPartialUpdateParamsWithContext(ctx context.Context) *DcimDeviceTypesPartialUpdateParams

+ func NewDcimDeviceTypesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesPartialUpdateParams

+ func NewDcimDeviceTypesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesPartialUpdateParams) SetData(data *models.DeviceType)

+ func (o *DcimDeviceTypesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesPartialUpdateParams) SetID(id int64)

+ func (o *DcimDeviceTypesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesPartialUpdateParams) WithContext(ctx context.Context) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) WithData(data *models.DeviceType) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) WithID(id int64) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesPartialUpdateParams

+ func (o *DcimDeviceTypesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesPartialUpdateReader struct

+ func (o *DcimDeviceTypesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesReadOK struct

+ Payload *models.DeviceType

+ func NewDcimDeviceTypesReadOK() *DcimDeviceTypesReadOK

+ func (o *DcimDeviceTypesReadOK) Error() string

+ type DcimDeviceTypesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceTypesReadParams() *DcimDeviceTypesReadParams

+ func NewDcimDeviceTypesReadParamsWithContext(ctx context.Context) *DcimDeviceTypesReadParams

+ func NewDcimDeviceTypesReadParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesReadParams

+ func NewDcimDeviceTypesReadParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesReadParams

+ func (o *DcimDeviceTypesReadParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesReadParams) SetID(id int64)

+ func (o *DcimDeviceTypesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesReadParams) WithContext(ctx context.Context) *DcimDeviceTypesReadParams

+ func (o *DcimDeviceTypesReadParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesReadParams

+ func (o *DcimDeviceTypesReadParams) WithID(id int64) *DcimDeviceTypesReadParams

+ func (o *DcimDeviceTypesReadParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesReadParams

+ func (o *DcimDeviceTypesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesReadReader struct

+ func (o *DcimDeviceTypesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDeviceTypesUpdateOK struct

+ Payload *models.DeviceType

+ func NewDcimDeviceTypesUpdateOK() *DcimDeviceTypesUpdateOK

+ func (o *DcimDeviceTypesUpdateOK) Error() string

+ type DcimDeviceTypesUpdateParams struct

+ Context context.Context

+ Data *models.DeviceType

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDeviceTypesUpdateParams() *DcimDeviceTypesUpdateParams

+ func NewDcimDeviceTypesUpdateParamsWithContext(ctx context.Context) *DcimDeviceTypesUpdateParams

+ func NewDcimDeviceTypesUpdateParamsWithHTTPClient(client *http.Client) *DcimDeviceTypesUpdateParams

+ func NewDcimDeviceTypesUpdateParamsWithTimeout(timeout time.Duration) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDeviceTypesUpdateParams) SetData(data *models.DeviceType)

+ func (o *DcimDeviceTypesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDeviceTypesUpdateParams) SetID(id int64)

+ func (o *DcimDeviceTypesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDeviceTypesUpdateParams) WithContext(ctx context.Context) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) WithData(data *models.DeviceType) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) WithHTTPClient(client *http.Client) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) WithID(id int64) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) WithTimeout(timeout time.Duration) *DcimDeviceTypesUpdateParams

+ func (o *DcimDeviceTypesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDeviceTypesUpdateReader struct

+ func (o *DcimDeviceTypesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesCreateCreated struct

+ Payload *models.Device

+ func NewDcimDevicesCreateCreated() *DcimDevicesCreateCreated

+ func (o *DcimDevicesCreateCreated) Error() string

+ type DcimDevicesCreateParams struct

+ Context context.Context

+ Data *models.Device

+ HTTPClient *http.Client

+ func NewDcimDevicesCreateParams() *DcimDevicesCreateParams

+ func NewDcimDevicesCreateParamsWithContext(ctx context.Context) *DcimDevicesCreateParams

+ func NewDcimDevicesCreateParamsWithHTTPClient(client *http.Client) *DcimDevicesCreateParams

+ func NewDcimDevicesCreateParamsWithTimeout(timeout time.Duration) *DcimDevicesCreateParams

+ func (o *DcimDevicesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesCreateParams) SetData(data *models.Device)

+ func (o *DcimDevicesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesCreateParams) WithContext(ctx context.Context) *DcimDevicesCreateParams

+ func (o *DcimDevicesCreateParams) WithData(data *models.Device) *DcimDevicesCreateParams

+ func (o *DcimDevicesCreateParams) WithHTTPClient(client *http.Client) *DcimDevicesCreateParams

+ func (o *DcimDevicesCreateParams) WithTimeout(timeout time.Duration) *DcimDevicesCreateParams

+ func (o *DcimDevicesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesCreateReader struct

+ func (o *DcimDevicesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesDeleteNoContent struct

+ func NewDcimDevicesDeleteNoContent() *DcimDevicesDeleteNoContent

+ func (o *DcimDevicesDeleteNoContent) Error() string

+ type DcimDevicesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDevicesDeleteParams() *DcimDevicesDeleteParams

+ func NewDcimDevicesDeleteParamsWithContext(ctx context.Context) *DcimDevicesDeleteParams

+ func NewDcimDevicesDeleteParamsWithHTTPClient(client *http.Client) *DcimDevicesDeleteParams

+ func NewDcimDevicesDeleteParamsWithTimeout(timeout time.Duration) *DcimDevicesDeleteParams

+ func (o *DcimDevicesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesDeleteParams) SetID(id int64)

+ func (o *DcimDevicesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesDeleteParams) WithContext(ctx context.Context) *DcimDevicesDeleteParams

+ func (o *DcimDevicesDeleteParams) WithHTTPClient(client *http.Client) *DcimDevicesDeleteParams

+ func (o *DcimDevicesDeleteParams) WithID(id int64) *DcimDevicesDeleteParams

+ func (o *DcimDevicesDeleteParams) WithTimeout(timeout time.Duration) *DcimDevicesDeleteParams

+ func (o *DcimDevicesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesDeleteReader struct

+ func (o *DcimDevicesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesListOK struct

+ Payload *DcimDevicesListOKBody

+ func NewDcimDevicesListOK() *DcimDevicesListOK

+ func (o *DcimDevicesListOK) Error() string

+ type DcimDevicesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Device

+ func (o *DcimDevicesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimDevicesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimDevicesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimDevicesListParams struct

+ AssetTag *string

+ ClusterID *string

+ Context context.Context

+ DeviceTypeID *string

+ HTTPClient *http.Client

+ HasPrimaryIP *string

+ IDIn *string

+ IsConsoleServer *string

+ IsFullDepth *string

+ IsNetworkDevice *string

+ IsPdu *string

+ Limit *int64

+ MacAddress *string

+ Manufacturer *string

+ ManufacturerID *string

+ Model *string

+ Name *string

+ Offset *int64

+ Platform *string

+ PlatformID *string

+ Position *float64

+ Q *string

+ RackGroupID *string

+ RackID *string

+ Role *string

+ RoleID *string

+ Serial *string

+ Site *string

+ SiteID *string

+ Status *string

+ Tag *string

+ Tenant *string

+ TenantID *string

+ VirtualChassisID *string

+ func NewDcimDevicesListParams() *DcimDevicesListParams

+ func NewDcimDevicesListParamsWithContext(ctx context.Context) *DcimDevicesListParams

+ func NewDcimDevicesListParamsWithHTTPClient(client *http.Client) *DcimDevicesListParams

+ func NewDcimDevicesListParamsWithTimeout(timeout time.Duration) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) SetAssetTag(assetTag *string)

+ func (o *DcimDevicesListParams) SetClusterID(clusterID *string)

+ func (o *DcimDevicesListParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesListParams) SetDeviceTypeID(deviceTypeID *string)

+ func (o *DcimDevicesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesListParams) SetHasPrimaryIP(hasPrimaryIP *string)

+ func (o *DcimDevicesListParams) SetIDIn(iDIn *string)

+ func (o *DcimDevicesListParams) SetIsConsoleServer(isConsoleServer *string)

+ func (o *DcimDevicesListParams) SetIsFullDepth(isFullDepth *string)

+ func (o *DcimDevicesListParams) SetIsNetworkDevice(isNetworkDevice *string)

+ func (o *DcimDevicesListParams) SetIsPdu(isPdu *string)

+ func (o *DcimDevicesListParams) SetLimit(limit *int64)

+ func (o *DcimDevicesListParams) SetMacAddress(macAddress *string)

+ func (o *DcimDevicesListParams) SetManufacturer(manufacturer *string)

+ func (o *DcimDevicesListParams) SetManufacturerID(manufacturerID *string)

+ func (o *DcimDevicesListParams) SetModel(model *string)

+ func (o *DcimDevicesListParams) SetName(name *string)

+ func (o *DcimDevicesListParams) SetOffset(offset *int64)

+ func (o *DcimDevicesListParams) SetPlatform(platform *string)

+ func (o *DcimDevicesListParams) SetPlatformID(platformID *string)

+ func (o *DcimDevicesListParams) SetPosition(position *float64)

+ func (o *DcimDevicesListParams) SetQ(q *string)

+ func (o *DcimDevicesListParams) SetRackGroupID(rackGroupID *string)

+ func (o *DcimDevicesListParams) SetRackID(rackID *string)

+ func (o *DcimDevicesListParams) SetRole(role *string)

+ func (o *DcimDevicesListParams) SetRoleID(roleID *string)

+ func (o *DcimDevicesListParams) SetSerial(serial *string)

+ func (o *DcimDevicesListParams) SetSite(site *string)

+ func (o *DcimDevicesListParams) SetSiteID(siteID *string)

+ func (o *DcimDevicesListParams) SetStatus(status *string)

+ func (o *DcimDevicesListParams) SetTag(tag *string)

+ func (o *DcimDevicesListParams) SetTenant(tenant *string)

+ func (o *DcimDevicesListParams) SetTenantID(tenantID *string)

+ func (o *DcimDevicesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesListParams) SetVirtualChassisID(virtualChassisID *string)

+ func (o *DcimDevicesListParams) WithAssetTag(assetTag *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithClusterID(clusterID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithContext(ctx context.Context) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithDeviceTypeID(deviceTypeID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithHTTPClient(client *http.Client) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithHasPrimaryIP(hasPrimaryIP *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithIDIn(iDIn *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithIsConsoleServer(isConsoleServer *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithIsFullDepth(isFullDepth *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithIsNetworkDevice(isNetworkDevice *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithIsPdu(isPdu *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithLimit(limit *int64) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithMacAddress(macAddress *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithManufacturer(manufacturer *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithManufacturerID(manufacturerID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithModel(model *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithName(name *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithOffset(offset *int64) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithPlatform(platform *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithPlatformID(platformID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithPosition(position *float64) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithQ(q *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithRackGroupID(rackGroupID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithRackID(rackID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithRole(role *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithRoleID(roleID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithSerial(serial *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithSite(site *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithSiteID(siteID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithStatus(status *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithTag(tag *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithTenant(tenant *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithTenantID(tenantID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithTimeout(timeout time.Duration) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WithVirtualChassisID(virtualChassisID *string) *DcimDevicesListParams

+ func (o *DcimDevicesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesListReader struct

+ func (o *DcimDevicesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesNapalmOK struct

+ Payload *models.Device

+ func NewDcimDevicesNapalmOK() *DcimDevicesNapalmOK

+ func (o *DcimDevicesNapalmOK) Error() string

+ type DcimDevicesNapalmParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDevicesNapalmParams() *DcimDevicesNapalmParams

+ func NewDcimDevicesNapalmParamsWithContext(ctx context.Context) *DcimDevicesNapalmParams

+ func NewDcimDevicesNapalmParamsWithHTTPClient(client *http.Client) *DcimDevicesNapalmParams

+ func NewDcimDevicesNapalmParamsWithTimeout(timeout time.Duration) *DcimDevicesNapalmParams

+ func (o *DcimDevicesNapalmParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesNapalmParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesNapalmParams) SetID(id int64)

+ func (o *DcimDevicesNapalmParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesNapalmParams) WithContext(ctx context.Context) *DcimDevicesNapalmParams

+ func (o *DcimDevicesNapalmParams) WithHTTPClient(client *http.Client) *DcimDevicesNapalmParams

+ func (o *DcimDevicesNapalmParams) WithID(id int64) *DcimDevicesNapalmParams

+ func (o *DcimDevicesNapalmParams) WithTimeout(timeout time.Duration) *DcimDevicesNapalmParams

+ func (o *DcimDevicesNapalmParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesNapalmReader struct

+ func (o *DcimDevicesNapalmReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesPartialUpdateOK struct

+ Payload *models.Device

+ func NewDcimDevicesPartialUpdateOK() *DcimDevicesPartialUpdateOK

+ func (o *DcimDevicesPartialUpdateOK) Error() string

+ type DcimDevicesPartialUpdateParams struct

+ Context context.Context

+ Data *models.Device

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDevicesPartialUpdateParams() *DcimDevicesPartialUpdateParams

+ func NewDcimDevicesPartialUpdateParamsWithContext(ctx context.Context) *DcimDevicesPartialUpdateParams

+ func NewDcimDevicesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimDevicesPartialUpdateParams

+ func NewDcimDevicesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesPartialUpdateParams) SetData(data *models.Device)

+ func (o *DcimDevicesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesPartialUpdateParams) SetID(id int64)

+ func (o *DcimDevicesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesPartialUpdateParams) WithContext(ctx context.Context) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) WithData(data *models.Device) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) WithID(id int64) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimDevicesPartialUpdateParams

+ func (o *DcimDevicesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesPartialUpdateReader struct

+ func (o *DcimDevicesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesReadOK struct

+ Payload *models.DeviceWithConfigContext

+ func NewDcimDevicesReadOK() *DcimDevicesReadOK

+ func (o *DcimDevicesReadOK) Error() string

+ type DcimDevicesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDevicesReadParams() *DcimDevicesReadParams

+ func NewDcimDevicesReadParamsWithContext(ctx context.Context) *DcimDevicesReadParams

+ func NewDcimDevicesReadParamsWithHTTPClient(client *http.Client) *DcimDevicesReadParams

+ func NewDcimDevicesReadParamsWithTimeout(timeout time.Duration) *DcimDevicesReadParams

+ func (o *DcimDevicesReadParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesReadParams) SetID(id int64)

+ func (o *DcimDevicesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesReadParams) WithContext(ctx context.Context) *DcimDevicesReadParams

+ func (o *DcimDevicesReadParams) WithHTTPClient(client *http.Client) *DcimDevicesReadParams

+ func (o *DcimDevicesReadParams) WithID(id int64) *DcimDevicesReadParams

+ func (o *DcimDevicesReadParams) WithTimeout(timeout time.Duration) *DcimDevicesReadParams

+ func (o *DcimDevicesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesReadReader struct

+ func (o *DcimDevicesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimDevicesUpdateOK struct

+ Payload *models.Device

+ func NewDcimDevicesUpdateOK() *DcimDevicesUpdateOK

+ func (o *DcimDevicesUpdateOK) Error() string

+ type DcimDevicesUpdateParams struct

+ Context context.Context

+ Data *models.Device

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimDevicesUpdateParams() *DcimDevicesUpdateParams

+ func NewDcimDevicesUpdateParamsWithContext(ctx context.Context) *DcimDevicesUpdateParams

+ func NewDcimDevicesUpdateParamsWithHTTPClient(client *http.Client) *DcimDevicesUpdateParams

+ func NewDcimDevicesUpdateParamsWithTimeout(timeout time.Duration) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimDevicesUpdateParams) SetData(data *models.Device)

+ func (o *DcimDevicesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimDevicesUpdateParams) SetID(id int64)

+ func (o *DcimDevicesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimDevicesUpdateParams) WithContext(ctx context.Context) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) WithData(data *models.Device) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) WithHTTPClient(client *http.Client) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) WithID(id int64) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) WithTimeout(timeout time.Duration) *DcimDevicesUpdateParams

+ func (o *DcimDevicesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimDevicesUpdateReader struct

+ func (o *DcimDevicesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsCreateCreated struct

+ Payload *models.InterfaceConnection

+ func NewDcimInterfaceConnectionsCreateCreated() *DcimInterfaceConnectionsCreateCreated

+ func (o *DcimInterfaceConnectionsCreateCreated) Error() string

+ type DcimInterfaceConnectionsCreateParams struct

+ Context context.Context

+ Data *models.InterfaceConnection

+ HTTPClient *http.Client

+ func NewDcimInterfaceConnectionsCreateParams() *DcimInterfaceConnectionsCreateParams

+ func NewDcimInterfaceConnectionsCreateParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsCreateParams

+ func NewDcimInterfaceConnectionsCreateParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsCreateParams

+ func NewDcimInterfaceConnectionsCreateParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsCreateParams

+ func (o *DcimInterfaceConnectionsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsCreateParams) SetData(data *models.InterfaceConnection)

+ func (o *DcimInterfaceConnectionsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsCreateParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsCreateParams

+ func (o *DcimInterfaceConnectionsCreateParams) WithData(data *models.InterfaceConnection) *DcimInterfaceConnectionsCreateParams

+ func (o *DcimInterfaceConnectionsCreateParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsCreateParams

+ func (o *DcimInterfaceConnectionsCreateParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsCreateParams

+ func (o *DcimInterfaceConnectionsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsCreateReader struct

+ func (o *DcimInterfaceConnectionsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsDeleteNoContent struct

+ func NewDcimInterfaceConnectionsDeleteNoContent() *DcimInterfaceConnectionsDeleteNoContent

+ func (o *DcimInterfaceConnectionsDeleteNoContent) Error() string

+ type DcimInterfaceConnectionsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceConnectionsDeleteParams() *DcimInterfaceConnectionsDeleteParams

+ func NewDcimInterfaceConnectionsDeleteParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsDeleteParams

+ func NewDcimInterfaceConnectionsDeleteParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsDeleteParams

+ func NewDcimInterfaceConnectionsDeleteParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsDeleteParams

+ func (o *DcimInterfaceConnectionsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsDeleteParams) SetID(id int64)

+ func (o *DcimInterfaceConnectionsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsDeleteParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsDeleteParams

+ func (o *DcimInterfaceConnectionsDeleteParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsDeleteParams

+ func (o *DcimInterfaceConnectionsDeleteParams) WithID(id int64) *DcimInterfaceConnectionsDeleteParams

+ func (o *DcimInterfaceConnectionsDeleteParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsDeleteParams

+ func (o *DcimInterfaceConnectionsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsDeleteReader struct

+ func (o *DcimInterfaceConnectionsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsListOK struct

+ Payload *DcimInterfaceConnectionsListOKBody

+ func NewDcimInterfaceConnectionsListOK() *DcimInterfaceConnectionsListOK

+ func (o *DcimInterfaceConnectionsListOK) Error() string

+ type DcimInterfaceConnectionsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.InterfaceConnection

+ func (o *DcimInterfaceConnectionsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimInterfaceConnectionsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimInterfaceConnectionsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimInterfaceConnectionsListParams struct

+ ConnectionStatus *string

+ Context context.Context

+ Device *string

+ HTTPClient *http.Client

+ Limit *int64

+ Offset *int64

+ Site *string

+ func NewDcimInterfaceConnectionsListParams() *DcimInterfaceConnectionsListParams

+ func NewDcimInterfaceConnectionsListParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsListParams

+ func NewDcimInterfaceConnectionsListParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsListParams

+ func NewDcimInterfaceConnectionsListParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) SetConnectionStatus(connectionStatus *string)

+ func (o *DcimInterfaceConnectionsListParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsListParams) SetDevice(device *string)

+ func (o *DcimInterfaceConnectionsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsListParams) SetLimit(limit *int64)

+ func (o *DcimInterfaceConnectionsListParams) SetOffset(offset *int64)

+ func (o *DcimInterfaceConnectionsListParams) SetSite(site *string)

+ func (o *DcimInterfaceConnectionsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsListParams) WithConnectionStatus(connectionStatus *string) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithDevice(device *string) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithLimit(limit *int64) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithOffset(offset *int64) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithSite(site *string) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsListParams

+ func (o *DcimInterfaceConnectionsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsListReader struct

+ func (o *DcimInterfaceConnectionsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsPartialUpdateOK struct

+ Payload *models.InterfaceConnection

+ func NewDcimInterfaceConnectionsPartialUpdateOK() *DcimInterfaceConnectionsPartialUpdateOK

+ func (o *DcimInterfaceConnectionsPartialUpdateOK) Error() string

+ type DcimInterfaceConnectionsPartialUpdateParams struct

+ Context context.Context

+ Data *models.InterfaceConnection

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceConnectionsPartialUpdateParams() *DcimInterfaceConnectionsPartialUpdateParams

+ func NewDcimInterfaceConnectionsPartialUpdateParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsPartialUpdateParams

+ func NewDcimInterfaceConnectionsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsPartialUpdateParams

+ func NewDcimInterfaceConnectionsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) SetData(data *models.InterfaceConnection)

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) SetID(id int64)

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WithData(data *models.InterfaceConnection) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WithID(id int64) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsPartialUpdateParams

+ func (o *DcimInterfaceConnectionsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsPartialUpdateReader struct

+ func (o *DcimInterfaceConnectionsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsReadOK struct

+ Payload *models.InterfaceConnection

+ func NewDcimInterfaceConnectionsReadOK() *DcimInterfaceConnectionsReadOK

+ func (o *DcimInterfaceConnectionsReadOK) Error() string

+ type DcimInterfaceConnectionsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceConnectionsReadParams() *DcimInterfaceConnectionsReadParams

+ func NewDcimInterfaceConnectionsReadParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsReadParams

+ func NewDcimInterfaceConnectionsReadParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsReadParams

+ func NewDcimInterfaceConnectionsReadParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsReadParams

+ func (o *DcimInterfaceConnectionsReadParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsReadParams) SetID(id int64)

+ func (o *DcimInterfaceConnectionsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsReadParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsReadParams

+ func (o *DcimInterfaceConnectionsReadParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsReadParams

+ func (o *DcimInterfaceConnectionsReadParams) WithID(id int64) *DcimInterfaceConnectionsReadParams

+ func (o *DcimInterfaceConnectionsReadParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsReadParams

+ func (o *DcimInterfaceConnectionsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsReadReader struct

+ func (o *DcimInterfaceConnectionsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceConnectionsUpdateOK struct

+ Payload *models.InterfaceConnection

+ func NewDcimInterfaceConnectionsUpdateOK() *DcimInterfaceConnectionsUpdateOK

+ func (o *DcimInterfaceConnectionsUpdateOK) Error() string

+ type DcimInterfaceConnectionsUpdateParams struct

+ Context context.Context

+ Data *models.InterfaceConnection

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceConnectionsUpdateParams() *DcimInterfaceConnectionsUpdateParams

+ func NewDcimInterfaceConnectionsUpdateParamsWithContext(ctx context.Context) *DcimInterfaceConnectionsUpdateParams

+ func NewDcimInterfaceConnectionsUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfaceConnectionsUpdateParams

+ func NewDcimInterfaceConnectionsUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceConnectionsUpdateParams) SetData(data *models.InterfaceConnection)

+ func (o *DcimInterfaceConnectionsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceConnectionsUpdateParams) SetID(id int64)

+ func (o *DcimInterfaceConnectionsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceConnectionsUpdateParams) WithContext(ctx context.Context) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) WithData(data *models.InterfaceConnection) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) WithID(id int64) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfaceConnectionsUpdateParams

+ func (o *DcimInterfaceConnectionsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceConnectionsUpdateReader struct

+ func (o *DcimInterfaceConnectionsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesCreateCreated struct

+ Payload *models.InterfaceTemplate

+ func NewDcimInterfaceTemplatesCreateCreated() *DcimInterfaceTemplatesCreateCreated

+ func (o *DcimInterfaceTemplatesCreateCreated) Error() string

+ type DcimInterfaceTemplatesCreateParams struct

+ Context context.Context

+ Data *models.InterfaceTemplate

+ HTTPClient *http.Client

+ func NewDcimInterfaceTemplatesCreateParams() *DcimInterfaceTemplatesCreateParams

+ func NewDcimInterfaceTemplatesCreateParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesCreateParams

+ func NewDcimInterfaceTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesCreateParams

+ func NewDcimInterfaceTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesCreateParams

+ func (o *DcimInterfaceTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesCreateParams) SetData(data *models.InterfaceTemplate)

+ func (o *DcimInterfaceTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesCreateParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesCreateParams

+ func (o *DcimInterfaceTemplatesCreateParams) WithData(data *models.InterfaceTemplate) *DcimInterfaceTemplatesCreateParams

+ func (o *DcimInterfaceTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesCreateParams

+ func (o *DcimInterfaceTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesCreateParams

+ func (o *DcimInterfaceTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesCreateReader struct

+ func (o *DcimInterfaceTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesDeleteNoContent struct

+ func NewDcimInterfaceTemplatesDeleteNoContent() *DcimInterfaceTemplatesDeleteNoContent

+ func (o *DcimInterfaceTemplatesDeleteNoContent) Error() string

+ type DcimInterfaceTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceTemplatesDeleteParams() *DcimInterfaceTemplatesDeleteParams

+ func NewDcimInterfaceTemplatesDeleteParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesDeleteParams

+ func NewDcimInterfaceTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesDeleteParams

+ func NewDcimInterfaceTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesDeleteParams

+ func (o *DcimInterfaceTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimInterfaceTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesDeleteParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesDeleteParams

+ func (o *DcimInterfaceTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesDeleteParams

+ func (o *DcimInterfaceTemplatesDeleteParams) WithID(id int64) *DcimInterfaceTemplatesDeleteParams

+ func (o *DcimInterfaceTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesDeleteParams

+ func (o *DcimInterfaceTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesDeleteReader struct

+ func (o *DcimInterfaceTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesListOK struct

+ Payload *DcimInterfaceTemplatesListOKBody

+ func NewDcimInterfaceTemplatesListOK() *DcimInterfaceTemplatesListOK

+ func (o *DcimInterfaceTemplatesListOK) Error() string

+ type DcimInterfaceTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.InterfaceTemplate

+ func (o *DcimInterfaceTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimInterfaceTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimInterfaceTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimInterfaceTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ FormFactor *string

+ HTTPClient *http.Client

+ Limit *int64

+ MgmtOnly *string

+ Name *string

+ Offset *int64

+ func NewDcimInterfaceTemplatesListParams() *DcimInterfaceTemplatesListParams

+ func NewDcimInterfaceTemplatesListParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesListParams

+ func NewDcimInterfaceTemplatesListParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesListParams

+ func NewDcimInterfaceTemplatesListParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimInterfaceTemplatesListParams) SetFormFactor(formFactor *string)

+ func (o *DcimInterfaceTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimInterfaceTemplatesListParams) SetMgmtOnly(mgmtOnly *string)

+ func (o *DcimInterfaceTemplatesListParams) SetName(name *string)

+ func (o *DcimInterfaceTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimInterfaceTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesListParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithFormFactor(formFactor *string) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithLimit(limit *int64) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithMgmtOnly(mgmtOnly *string) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithName(name *string) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithOffset(offset *int64) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesListParams

+ func (o *DcimInterfaceTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesListReader struct

+ func (o *DcimInterfaceTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesPartialUpdateOK struct

+ Payload *models.InterfaceTemplate

+ func NewDcimInterfaceTemplatesPartialUpdateOK() *DcimInterfaceTemplatesPartialUpdateOK

+ func (o *DcimInterfaceTemplatesPartialUpdateOK) Error() string

+ type DcimInterfaceTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.InterfaceTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceTemplatesPartialUpdateParams() *DcimInterfaceTemplatesPartialUpdateParams

+ func NewDcimInterfaceTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesPartialUpdateParams

+ func NewDcimInterfaceTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesPartialUpdateParams

+ func NewDcimInterfaceTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) SetData(data *models.InterfaceTemplate)

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WithData(data *models.InterfaceTemplate) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WithID(id int64) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesPartialUpdateParams

+ func (o *DcimInterfaceTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesPartialUpdateReader struct

+ func (o *DcimInterfaceTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesReadOK struct

+ Payload *models.InterfaceTemplate

+ func NewDcimInterfaceTemplatesReadOK() *DcimInterfaceTemplatesReadOK

+ func (o *DcimInterfaceTemplatesReadOK) Error() string

+ type DcimInterfaceTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceTemplatesReadParams() *DcimInterfaceTemplatesReadParams

+ func NewDcimInterfaceTemplatesReadParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesReadParams

+ func NewDcimInterfaceTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesReadParams

+ func NewDcimInterfaceTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesReadParams

+ func (o *DcimInterfaceTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesReadParams) SetID(id int64)

+ func (o *DcimInterfaceTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesReadParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesReadParams

+ func (o *DcimInterfaceTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesReadParams

+ func (o *DcimInterfaceTemplatesReadParams) WithID(id int64) *DcimInterfaceTemplatesReadParams

+ func (o *DcimInterfaceTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesReadParams

+ func (o *DcimInterfaceTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesReadReader struct

+ func (o *DcimInterfaceTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfaceTemplatesUpdateOK struct

+ Payload *models.InterfaceTemplate

+ func NewDcimInterfaceTemplatesUpdateOK() *DcimInterfaceTemplatesUpdateOK

+ func (o *DcimInterfaceTemplatesUpdateOK) Error() string

+ type DcimInterfaceTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.InterfaceTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfaceTemplatesUpdateParams() *DcimInterfaceTemplatesUpdateParams

+ func NewDcimInterfaceTemplatesUpdateParamsWithContext(ctx context.Context) *DcimInterfaceTemplatesUpdateParams

+ func NewDcimInterfaceTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfaceTemplatesUpdateParams

+ func NewDcimInterfaceTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfaceTemplatesUpdateParams) SetData(data *models.InterfaceTemplate)

+ func (o *DcimInterfaceTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfaceTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimInterfaceTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfaceTemplatesUpdateParams) WithContext(ctx context.Context) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) WithData(data *models.InterfaceTemplate) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) WithID(id int64) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfaceTemplatesUpdateParams

+ func (o *DcimInterfaceTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfaceTemplatesUpdateReader struct

+ func (o *DcimInterfaceTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesCreateCreated struct

+ Payload *models.Interface

+ func NewDcimInterfacesCreateCreated() *DcimInterfacesCreateCreated

+ func (o *DcimInterfacesCreateCreated) Error() string

+ type DcimInterfacesCreateParams struct

+ Context context.Context

+ Data *models.Interface

+ HTTPClient *http.Client

+ func NewDcimInterfacesCreateParams() *DcimInterfacesCreateParams

+ func NewDcimInterfacesCreateParamsWithContext(ctx context.Context) *DcimInterfacesCreateParams

+ func NewDcimInterfacesCreateParamsWithHTTPClient(client *http.Client) *DcimInterfacesCreateParams

+ func NewDcimInterfacesCreateParamsWithTimeout(timeout time.Duration) *DcimInterfacesCreateParams

+ func (o *DcimInterfacesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesCreateParams) SetData(data *models.Interface)

+ func (o *DcimInterfacesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesCreateParams) WithContext(ctx context.Context) *DcimInterfacesCreateParams

+ func (o *DcimInterfacesCreateParams) WithData(data *models.Interface) *DcimInterfacesCreateParams

+ func (o *DcimInterfacesCreateParams) WithHTTPClient(client *http.Client) *DcimInterfacesCreateParams

+ func (o *DcimInterfacesCreateParams) WithTimeout(timeout time.Duration) *DcimInterfacesCreateParams

+ func (o *DcimInterfacesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesCreateReader struct

+ func (o *DcimInterfacesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesDeleteNoContent struct

+ func NewDcimInterfacesDeleteNoContent() *DcimInterfacesDeleteNoContent

+ func (o *DcimInterfacesDeleteNoContent) Error() string

+ type DcimInterfacesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfacesDeleteParams() *DcimInterfacesDeleteParams

+ func NewDcimInterfacesDeleteParamsWithContext(ctx context.Context) *DcimInterfacesDeleteParams

+ func NewDcimInterfacesDeleteParamsWithHTTPClient(client *http.Client) *DcimInterfacesDeleteParams

+ func NewDcimInterfacesDeleteParamsWithTimeout(timeout time.Duration) *DcimInterfacesDeleteParams

+ func (o *DcimInterfacesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesDeleteParams) SetID(id int64)

+ func (o *DcimInterfacesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesDeleteParams) WithContext(ctx context.Context) *DcimInterfacesDeleteParams

+ func (o *DcimInterfacesDeleteParams) WithHTTPClient(client *http.Client) *DcimInterfacesDeleteParams

+ func (o *DcimInterfacesDeleteParams) WithID(id int64) *DcimInterfacesDeleteParams

+ func (o *DcimInterfacesDeleteParams) WithTimeout(timeout time.Duration) *DcimInterfacesDeleteParams

+ func (o *DcimInterfacesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesDeleteReader struct

+ func (o *DcimInterfacesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesGraphsOK struct

+ Payload *models.Interface

+ func NewDcimInterfacesGraphsOK() *DcimInterfacesGraphsOK

+ func (o *DcimInterfacesGraphsOK) Error() string

+ type DcimInterfacesGraphsParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfacesGraphsParams() *DcimInterfacesGraphsParams

+ func NewDcimInterfacesGraphsParamsWithContext(ctx context.Context) *DcimInterfacesGraphsParams

+ func NewDcimInterfacesGraphsParamsWithHTTPClient(client *http.Client) *DcimInterfacesGraphsParams

+ func NewDcimInterfacesGraphsParamsWithTimeout(timeout time.Duration) *DcimInterfacesGraphsParams

+ func (o *DcimInterfacesGraphsParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesGraphsParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesGraphsParams) SetID(id int64)

+ func (o *DcimInterfacesGraphsParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesGraphsParams) WithContext(ctx context.Context) *DcimInterfacesGraphsParams

+ func (o *DcimInterfacesGraphsParams) WithHTTPClient(client *http.Client) *DcimInterfacesGraphsParams

+ func (o *DcimInterfacesGraphsParams) WithID(id int64) *DcimInterfacesGraphsParams

+ func (o *DcimInterfacesGraphsParams) WithTimeout(timeout time.Duration) *DcimInterfacesGraphsParams

+ func (o *DcimInterfacesGraphsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesGraphsReader struct

+ func (o *DcimInterfacesGraphsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesListOK struct

+ Payload *DcimInterfacesListOKBody

+ func NewDcimInterfacesListOK() *DcimInterfacesListOK

+ func (o *DcimInterfacesListOK) Error() string

+ type DcimInterfacesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Interface

+ func (o *DcimInterfacesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimInterfacesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimInterfacesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimInterfacesListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *float64

+ Enabled *string

+ FormFactor *string

+ HTTPClient *http.Client

+ LagID *string

+ Limit *int64

+ MacAddress *string

+ MgmtOnly *string

+ Mtu *float64

+ Name *string

+ Offset *int64

+ Tag *string

+ Type *string

+ func NewDcimInterfacesListParams() *DcimInterfacesListParams

+ func NewDcimInterfacesListParamsWithContext(ctx context.Context) *DcimInterfacesListParams

+ func NewDcimInterfacesListParamsWithHTTPClient(client *http.Client) *DcimInterfacesListParams

+ func NewDcimInterfacesListParamsWithTimeout(timeout time.Duration) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesListParams) SetDevice(device *string)

+ func (o *DcimInterfacesListParams) SetDeviceID(deviceID *float64)

+ func (o *DcimInterfacesListParams) SetEnabled(enabled *string)

+ func (o *DcimInterfacesListParams) SetFormFactor(formFactor *string)

+ func (o *DcimInterfacesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesListParams) SetLagID(lagID *string)

+ func (o *DcimInterfacesListParams) SetLimit(limit *int64)

+ func (o *DcimInterfacesListParams) SetMacAddress(macAddress *string)

+ func (o *DcimInterfacesListParams) SetMgmtOnly(mgmtOnly *string)

+ func (o *DcimInterfacesListParams) SetMtu(mtu *float64)

+ func (o *DcimInterfacesListParams) SetName(name *string)

+ func (o *DcimInterfacesListParams) SetOffset(offset *int64)

+ func (o *DcimInterfacesListParams) SetTag(tag *string)

+ func (o *DcimInterfacesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesListParams) SetType(typeVar *string)

+ func (o *DcimInterfacesListParams) WithContext(ctx context.Context) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithDevice(device *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithDeviceID(deviceID *float64) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithEnabled(enabled *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithFormFactor(formFactor *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithHTTPClient(client *http.Client) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithLagID(lagID *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithLimit(limit *int64) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithMacAddress(macAddress *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithMgmtOnly(mgmtOnly *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithMtu(mtu *float64) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithName(name *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithOffset(offset *int64) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithTag(tag *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithTimeout(timeout time.Duration) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WithType(typeVar *string) *DcimInterfacesListParams

+ func (o *DcimInterfacesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesListReader struct

+ func (o *DcimInterfacesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesPartialUpdateOK struct

+ Payload *models.Interface

+ func NewDcimInterfacesPartialUpdateOK() *DcimInterfacesPartialUpdateOK

+ func (o *DcimInterfacesPartialUpdateOK) Error() string

+ type DcimInterfacesPartialUpdateParams struct

+ Context context.Context

+ Data *models.Interface

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfacesPartialUpdateParams() *DcimInterfacesPartialUpdateParams

+ func NewDcimInterfacesPartialUpdateParamsWithContext(ctx context.Context) *DcimInterfacesPartialUpdateParams

+ func NewDcimInterfacesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfacesPartialUpdateParams

+ func NewDcimInterfacesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesPartialUpdateParams) SetData(data *models.Interface)

+ func (o *DcimInterfacesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesPartialUpdateParams) SetID(id int64)

+ func (o *DcimInterfacesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesPartialUpdateParams) WithContext(ctx context.Context) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) WithData(data *models.Interface) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) WithID(id int64) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfacesPartialUpdateParams

+ func (o *DcimInterfacesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesPartialUpdateReader struct

+ func (o *DcimInterfacesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesReadOK struct

+ Payload *models.Interface

+ func NewDcimInterfacesReadOK() *DcimInterfacesReadOK

+ func (o *DcimInterfacesReadOK) Error() string

+ type DcimInterfacesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfacesReadParams() *DcimInterfacesReadParams

+ func NewDcimInterfacesReadParamsWithContext(ctx context.Context) *DcimInterfacesReadParams

+ func NewDcimInterfacesReadParamsWithHTTPClient(client *http.Client) *DcimInterfacesReadParams

+ func NewDcimInterfacesReadParamsWithTimeout(timeout time.Duration) *DcimInterfacesReadParams

+ func (o *DcimInterfacesReadParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesReadParams) SetID(id int64)

+ func (o *DcimInterfacesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesReadParams) WithContext(ctx context.Context) *DcimInterfacesReadParams

+ func (o *DcimInterfacesReadParams) WithHTTPClient(client *http.Client) *DcimInterfacesReadParams

+ func (o *DcimInterfacesReadParams) WithID(id int64) *DcimInterfacesReadParams

+ func (o *DcimInterfacesReadParams) WithTimeout(timeout time.Duration) *DcimInterfacesReadParams

+ func (o *DcimInterfacesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesReadReader struct

+ func (o *DcimInterfacesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInterfacesUpdateOK struct

+ Payload *models.Interface

+ func NewDcimInterfacesUpdateOK() *DcimInterfacesUpdateOK

+ func (o *DcimInterfacesUpdateOK) Error() string

+ type DcimInterfacesUpdateParams struct

+ Context context.Context

+ Data *models.Interface

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInterfacesUpdateParams() *DcimInterfacesUpdateParams

+ func NewDcimInterfacesUpdateParamsWithContext(ctx context.Context) *DcimInterfacesUpdateParams

+ func NewDcimInterfacesUpdateParamsWithHTTPClient(client *http.Client) *DcimInterfacesUpdateParams

+ func NewDcimInterfacesUpdateParamsWithTimeout(timeout time.Duration) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInterfacesUpdateParams) SetData(data *models.Interface)

+ func (o *DcimInterfacesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInterfacesUpdateParams) SetID(id int64)

+ func (o *DcimInterfacesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInterfacesUpdateParams) WithContext(ctx context.Context) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) WithData(data *models.Interface) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) WithHTTPClient(client *http.Client) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) WithID(id int64) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) WithTimeout(timeout time.Duration) *DcimInterfacesUpdateParams

+ func (o *DcimInterfacesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInterfacesUpdateReader struct

+ func (o *DcimInterfacesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsCreateCreated struct

+ Payload *models.InventoryItem

+ func NewDcimInventoryItemsCreateCreated() *DcimInventoryItemsCreateCreated

+ func (o *DcimInventoryItemsCreateCreated) Error() string

+ type DcimInventoryItemsCreateParams struct

+ Context context.Context

+ Data *models.InventoryItem

+ HTTPClient *http.Client

+ func NewDcimInventoryItemsCreateParams() *DcimInventoryItemsCreateParams

+ func NewDcimInventoryItemsCreateParamsWithContext(ctx context.Context) *DcimInventoryItemsCreateParams

+ func NewDcimInventoryItemsCreateParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsCreateParams

+ func NewDcimInventoryItemsCreateParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsCreateParams

+ func (o *DcimInventoryItemsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsCreateParams) SetData(data *models.InventoryItem)

+ func (o *DcimInventoryItemsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsCreateParams) WithContext(ctx context.Context) *DcimInventoryItemsCreateParams

+ func (o *DcimInventoryItemsCreateParams) WithData(data *models.InventoryItem) *DcimInventoryItemsCreateParams

+ func (o *DcimInventoryItemsCreateParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsCreateParams

+ func (o *DcimInventoryItemsCreateParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsCreateParams

+ func (o *DcimInventoryItemsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsCreateReader struct

+ func (o *DcimInventoryItemsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsDeleteNoContent struct

+ func NewDcimInventoryItemsDeleteNoContent() *DcimInventoryItemsDeleteNoContent

+ func (o *DcimInventoryItemsDeleteNoContent) Error() string

+ type DcimInventoryItemsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInventoryItemsDeleteParams() *DcimInventoryItemsDeleteParams

+ func NewDcimInventoryItemsDeleteParamsWithContext(ctx context.Context) *DcimInventoryItemsDeleteParams

+ func NewDcimInventoryItemsDeleteParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsDeleteParams

+ func NewDcimInventoryItemsDeleteParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsDeleteParams

+ func (o *DcimInventoryItemsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsDeleteParams) SetID(id int64)

+ func (o *DcimInventoryItemsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsDeleteParams) WithContext(ctx context.Context) *DcimInventoryItemsDeleteParams

+ func (o *DcimInventoryItemsDeleteParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsDeleteParams

+ func (o *DcimInventoryItemsDeleteParams) WithID(id int64) *DcimInventoryItemsDeleteParams

+ func (o *DcimInventoryItemsDeleteParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsDeleteParams

+ func (o *DcimInventoryItemsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsDeleteReader struct

+ func (o *DcimInventoryItemsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsListOK struct

+ Payload *DcimInventoryItemsListOKBody

+ func NewDcimInventoryItemsListOK() *DcimInventoryItemsListOK

+ func (o *DcimInventoryItemsListOK) Error() string

+ type DcimInventoryItemsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.InventoryItem

+ func (o *DcimInventoryItemsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimInventoryItemsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimInventoryItemsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimInventoryItemsListParams struct

+ AssetTag *string

+ Context context.Context

+ Device *string

+ DeviceID *string

+ Discovered *string

+ HTTPClient *http.Client

+ Limit *int64

+ Manufacturer *string

+ ManufacturerID *string

+ Name *string

+ Offset *int64

+ ParentID *string

+ PartID *string

+ Q *string

+ Serial *string

+ Tag *string

+ func NewDcimInventoryItemsListParams() *DcimInventoryItemsListParams

+ func NewDcimInventoryItemsListParamsWithContext(ctx context.Context) *DcimInventoryItemsListParams

+ func NewDcimInventoryItemsListParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsListParams

+ func NewDcimInventoryItemsListParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) SetAssetTag(assetTag *string)

+ func (o *DcimInventoryItemsListParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsListParams) SetDevice(device *string)

+ func (o *DcimInventoryItemsListParams) SetDeviceID(deviceID *string)

+ func (o *DcimInventoryItemsListParams) SetDiscovered(discovered *string)

+ func (o *DcimInventoryItemsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsListParams) SetLimit(limit *int64)

+ func (o *DcimInventoryItemsListParams) SetManufacturer(manufacturer *string)

+ func (o *DcimInventoryItemsListParams) SetManufacturerID(manufacturerID *string)

+ func (o *DcimInventoryItemsListParams) SetName(name *string)

+ func (o *DcimInventoryItemsListParams) SetOffset(offset *int64)

+ func (o *DcimInventoryItemsListParams) SetParentID(parentID *string)

+ func (o *DcimInventoryItemsListParams) SetPartID(partID *string)

+ func (o *DcimInventoryItemsListParams) SetQ(q *string)

+ func (o *DcimInventoryItemsListParams) SetSerial(serial *string)

+ func (o *DcimInventoryItemsListParams) SetTag(tag *string)

+ func (o *DcimInventoryItemsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsListParams) WithAssetTag(assetTag *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithContext(ctx context.Context) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithDevice(device *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithDeviceID(deviceID *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithDiscovered(discovered *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithLimit(limit *int64) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithManufacturer(manufacturer *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithManufacturerID(manufacturerID *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithName(name *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithOffset(offset *int64) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithParentID(parentID *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithPartID(partID *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithQ(q *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithSerial(serial *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithTag(tag *string) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsListParams

+ func (o *DcimInventoryItemsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsListReader struct

+ func (o *DcimInventoryItemsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsPartialUpdateOK struct

+ Payload *models.InventoryItem

+ func NewDcimInventoryItemsPartialUpdateOK() *DcimInventoryItemsPartialUpdateOK

+ func (o *DcimInventoryItemsPartialUpdateOK) Error() string

+ type DcimInventoryItemsPartialUpdateParams struct

+ Context context.Context

+ Data *models.InventoryItem

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInventoryItemsPartialUpdateParams() *DcimInventoryItemsPartialUpdateParams

+ func NewDcimInventoryItemsPartialUpdateParamsWithContext(ctx context.Context) *DcimInventoryItemsPartialUpdateParams

+ func NewDcimInventoryItemsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsPartialUpdateParams

+ func NewDcimInventoryItemsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsPartialUpdateParams) SetData(data *models.InventoryItem)

+ func (o *DcimInventoryItemsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsPartialUpdateParams) SetID(id int64)

+ func (o *DcimInventoryItemsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsPartialUpdateParams) WithContext(ctx context.Context) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) WithData(data *models.InventoryItem) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) WithID(id int64) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsPartialUpdateParams

+ func (o *DcimInventoryItemsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsPartialUpdateReader struct

+ func (o *DcimInventoryItemsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsReadOK struct

+ Payload *models.InventoryItem

+ func NewDcimInventoryItemsReadOK() *DcimInventoryItemsReadOK

+ func (o *DcimInventoryItemsReadOK) Error() string

+ type DcimInventoryItemsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInventoryItemsReadParams() *DcimInventoryItemsReadParams

+ func NewDcimInventoryItemsReadParamsWithContext(ctx context.Context) *DcimInventoryItemsReadParams

+ func NewDcimInventoryItemsReadParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsReadParams

+ func NewDcimInventoryItemsReadParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsReadParams

+ func (o *DcimInventoryItemsReadParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsReadParams) SetID(id int64)

+ func (o *DcimInventoryItemsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsReadParams) WithContext(ctx context.Context) *DcimInventoryItemsReadParams

+ func (o *DcimInventoryItemsReadParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsReadParams

+ func (o *DcimInventoryItemsReadParams) WithID(id int64) *DcimInventoryItemsReadParams

+ func (o *DcimInventoryItemsReadParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsReadParams

+ func (o *DcimInventoryItemsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsReadReader struct

+ func (o *DcimInventoryItemsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimInventoryItemsUpdateOK struct

+ Payload *models.InventoryItem

+ func NewDcimInventoryItemsUpdateOK() *DcimInventoryItemsUpdateOK

+ func (o *DcimInventoryItemsUpdateOK) Error() string

+ type DcimInventoryItemsUpdateParams struct

+ Context context.Context

+ Data *models.InventoryItem

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimInventoryItemsUpdateParams() *DcimInventoryItemsUpdateParams

+ func NewDcimInventoryItemsUpdateParamsWithContext(ctx context.Context) *DcimInventoryItemsUpdateParams

+ func NewDcimInventoryItemsUpdateParamsWithHTTPClient(client *http.Client) *DcimInventoryItemsUpdateParams

+ func NewDcimInventoryItemsUpdateParamsWithTimeout(timeout time.Duration) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimInventoryItemsUpdateParams) SetData(data *models.InventoryItem)

+ func (o *DcimInventoryItemsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimInventoryItemsUpdateParams) SetID(id int64)

+ func (o *DcimInventoryItemsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimInventoryItemsUpdateParams) WithContext(ctx context.Context) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) WithData(data *models.InventoryItem) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) WithHTTPClient(client *http.Client) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) WithID(id int64) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) WithTimeout(timeout time.Duration) *DcimInventoryItemsUpdateParams

+ func (o *DcimInventoryItemsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimInventoryItemsUpdateReader struct

+ func (o *DcimInventoryItemsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersCreateCreated struct

+ Payload *models.Manufacturer

+ func NewDcimManufacturersCreateCreated() *DcimManufacturersCreateCreated

+ func (o *DcimManufacturersCreateCreated) Error() string

+ type DcimManufacturersCreateParams struct

+ Context context.Context

+ Data *models.Manufacturer

+ HTTPClient *http.Client

+ func NewDcimManufacturersCreateParams() *DcimManufacturersCreateParams

+ func NewDcimManufacturersCreateParamsWithContext(ctx context.Context) *DcimManufacturersCreateParams

+ func NewDcimManufacturersCreateParamsWithHTTPClient(client *http.Client) *DcimManufacturersCreateParams

+ func NewDcimManufacturersCreateParamsWithTimeout(timeout time.Duration) *DcimManufacturersCreateParams

+ func (o *DcimManufacturersCreateParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersCreateParams) SetData(data *models.Manufacturer)

+ func (o *DcimManufacturersCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersCreateParams) WithContext(ctx context.Context) *DcimManufacturersCreateParams

+ func (o *DcimManufacturersCreateParams) WithData(data *models.Manufacturer) *DcimManufacturersCreateParams

+ func (o *DcimManufacturersCreateParams) WithHTTPClient(client *http.Client) *DcimManufacturersCreateParams

+ func (o *DcimManufacturersCreateParams) WithTimeout(timeout time.Duration) *DcimManufacturersCreateParams

+ func (o *DcimManufacturersCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersCreateReader struct

+ func (o *DcimManufacturersCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersDeleteNoContent struct

+ func NewDcimManufacturersDeleteNoContent() *DcimManufacturersDeleteNoContent

+ func (o *DcimManufacturersDeleteNoContent) Error() string

+ type DcimManufacturersDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimManufacturersDeleteParams() *DcimManufacturersDeleteParams

+ func NewDcimManufacturersDeleteParamsWithContext(ctx context.Context) *DcimManufacturersDeleteParams

+ func NewDcimManufacturersDeleteParamsWithHTTPClient(client *http.Client) *DcimManufacturersDeleteParams

+ func NewDcimManufacturersDeleteParamsWithTimeout(timeout time.Duration) *DcimManufacturersDeleteParams

+ func (o *DcimManufacturersDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersDeleteParams) SetID(id int64)

+ func (o *DcimManufacturersDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersDeleteParams) WithContext(ctx context.Context) *DcimManufacturersDeleteParams

+ func (o *DcimManufacturersDeleteParams) WithHTTPClient(client *http.Client) *DcimManufacturersDeleteParams

+ func (o *DcimManufacturersDeleteParams) WithID(id int64) *DcimManufacturersDeleteParams

+ func (o *DcimManufacturersDeleteParams) WithTimeout(timeout time.Duration) *DcimManufacturersDeleteParams

+ func (o *DcimManufacturersDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersDeleteReader struct

+ func (o *DcimManufacturersDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersListOK struct

+ Payload *DcimManufacturersListOKBody

+ func NewDcimManufacturersListOK() *DcimManufacturersListOK

+ func (o *DcimManufacturersListOK) Error() string

+ type DcimManufacturersListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Manufacturer

+ func (o *DcimManufacturersListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimManufacturersListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimManufacturersListOKBody) Validate(formats strfmt.Registry) error

+ type DcimManufacturersListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Slug *string

+ func NewDcimManufacturersListParams() *DcimManufacturersListParams

+ func NewDcimManufacturersListParamsWithContext(ctx context.Context) *DcimManufacturersListParams

+ func NewDcimManufacturersListParamsWithHTTPClient(client *http.Client) *DcimManufacturersListParams

+ func NewDcimManufacturersListParamsWithTimeout(timeout time.Duration) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersListParams) SetLimit(limit *int64)

+ func (o *DcimManufacturersListParams) SetName(name *string)

+ func (o *DcimManufacturersListParams) SetOffset(offset *int64)

+ func (o *DcimManufacturersListParams) SetSlug(slug *string)

+ func (o *DcimManufacturersListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersListParams) WithContext(ctx context.Context) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithHTTPClient(client *http.Client) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithLimit(limit *int64) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithName(name *string) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithOffset(offset *int64) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithSlug(slug *string) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WithTimeout(timeout time.Duration) *DcimManufacturersListParams

+ func (o *DcimManufacturersListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersListReader struct

+ func (o *DcimManufacturersListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersPartialUpdateOK struct

+ Payload *models.Manufacturer

+ func NewDcimManufacturersPartialUpdateOK() *DcimManufacturersPartialUpdateOK

+ func (o *DcimManufacturersPartialUpdateOK) Error() string

+ type DcimManufacturersPartialUpdateParams struct

+ Context context.Context

+ Data *models.Manufacturer

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimManufacturersPartialUpdateParams() *DcimManufacturersPartialUpdateParams

+ func NewDcimManufacturersPartialUpdateParamsWithContext(ctx context.Context) *DcimManufacturersPartialUpdateParams

+ func NewDcimManufacturersPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimManufacturersPartialUpdateParams

+ func NewDcimManufacturersPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersPartialUpdateParams) SetData(data *models.Manufacturer)

+ func (o *DcimManufacturersPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersPartialUpdateParams) SetID(id int64)

+ func (o *DcimManufacturersPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersPartialUpdateParams) WithContext(ctx context.Context) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) WithData(data *models.Manufacturer) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) WithID(id int64) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimManufacturersPartialUpdateParams

+ func (o *DcimManufacturersPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersPartialUpdateReader struct

+ func (o *DcimManufacturersPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersReadOK struct

+ Payload *models.Manufacturer

+ func NewDcimManufacturersReadOK() *DcimManufacturersReadOK

+ func (o *DcimManufacturersReadOK) Error() string

+ type DcimManufacturersReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimManufacturersReadParams() *DcimManufacturersReadParams

+ func NewDcimManufacturersReadParamsWithContext(ctx context.Context) *DcimManufacturersReadParams

+ func NewDcimManufacturersReadParamsWithHTTPClient(client *http.Client) *DcimManufacturersReadParams

+ func NewDcimManufacturersReadParamsWithTimeout(timeout time.Duration) *DcimManufacturersReadParams

+ func (o *DcimManufacturersReadParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersReadParams) SetID(id int64)

+ func (o *DcimManufacturersReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersReadParams) WithContext(ctx context.Context) *DcimManufacturersReadParams

+ func (o *DcimManufacturersReadParams) WithHTTPClient(client *http.Client) *DcimManufacturersReadParams

+ func (o *DcimManufacturersReadParams) WithID(id int64) *DcimManufacturersReadParams

+ func (o *DcimManufacturersReadParams) WithTimeout(timeout time.Duration) *DcimManufacturersReadParams

+ func (o *DcimManufacturersReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersReadReader struct

+ func (o *DcimManufacturersReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimManufacturersUpdateOK struct

+ Payload *models.Manufacturer

+ func NewDcimManufacturersUpdateOK() *DcimManufacturersUpdateOK

+ func (o *DcimManufacturersUpdateOK) Error() string

+ type DcimManufacturersUpdateParams struct

+ Context context.Context

+ Data *models.Manufacturer

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimManufacturersUpdateParams() *DcimManufacturersUpdateParams

+ func NewDcimManufacturersUpdateParamsWithContext(ctx context.Context) *DcimManufacturersUpdateParams

+ func NewDcimManufacturersUpdateParamsWithHTTPClient(client *http.Client) *DcimManufacturersUpdateParams

+ func NewDcimManufacturersUpdateParamsWithTimeout(timeout time.Duration) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimManufacturersUpdateParams) SetData(data *models.Manufacturer)

+ func (o *DcimManufacturersUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimManufacturersUpdateParams) SetID(id int64)

+ func (o *DcimManufacturersUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimManufacturersUpdateParams) WithContext(ctx context.Context) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) WithData(data *models.Manufacturer) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) WithHTTPClient(client *http.Client) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) WithID(id int64) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) WithTimeout(timeout time.Duration) *DcimManufacturersUpdateParams

+ func (o *DcimManufacturersUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimManufacturersUpdateReader struct

+ func (o *DcimManufacturersUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsCreateCreated struct

+ Payload *models.Platform

+ func NewDcimPlatformsCreateCreated() *DcimPlatformsCreateCreated

+ func (o *DcimPlatformsCreateCreated) Error() string

+ type DcimPlatformsCreateParams struct

+ Context context.Context

+ Data *models.Platform

+ HTTPClient *http.Client

+ func NewDcimPlatformsCreateParams() *DcimPlatformsCreateParams

+ func NewDcimPlatformsCreateParamsWithContext(ctx context.Context) *DcimPlatformsCreateParams

+ func NewDcimPlatformsCreateParamsWithHTTPClient(client *http.Client) *DcimPlatformsCreateParams

+ func NewDcimPlatformsCreateParamsWithTimeout(timeout time.Duration) *DcimPlatformsCreateParams

+ func (o *DcimPlatformsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsCreateParams) SetData(data *models.Platform)

+ func (o *DcimPlatformsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsCreateParams) WithContext(ctx context.Context) *DcimPlatformsCreateParams

+ func (o *DcimPlatformsCreateParams) WithData(data *models.Platform) *DcimPlatformsCreateParams

+ func (o *DcimPlatformsCreateParams) WithHTTPClient(client *http.Client) *DcimPlatformsCreateParams

+ func (o *DcimPlatformsCreateParams) WithTimeout(timeout time.Duration) *DcimPlatformsCreateParams

+ func (o *DcimPlatformsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsCreateReader struct

+ func (o *DcimPlatformsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsDeleteNoContent struct

+ func NewDcimPlatformsDeleteNoContent() *DcimPlatformsDeleteNoContent

+ func (o *DcimPlatformsDeleteNoContent) Error() string

+ type DcimPlatformsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPlatformsDeleteParams() *DcimPlatformsDeleteParams

+ func NewDcimPlatformsDeleteParamsWithContext(ctx context.Context) *DcimPlatformsDeleteParams

+ func NewDcimPlatformsDeleteParamsWithHTTPClient(client *http.Client) *DcimPlatformsDeleteParams

+ func NewDcimPlatformsDeleteParamsWithTimeout(timeout time.Duration) *DcimPlatformsDeleteParams

+ func (o *DcimPlatformsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsDeleteParams) SetID(id int64)

+ func (o *DcimPlatformsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsDeleteParams) WithContext(ctx context.Context) *DcimPlatformsDeleteParams

+ func (o *DcimPlatformsDeleteParams) WithHTTPClient(client *http.Client) *DcimPlatformsDeleteParams

+ func (o *DcimPlatformsDeleteParams) WithID(id int64) *DcimPlatformsDeleteParams

+ func (o *DcimPlatformsDeleteParams) WithTimeout(timeout time.Duration) *DcimPlatformsDeleteParams

+ func (o *DcimPlatformsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsDeleteReader struct

+ func (o *DcimPlatformsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsListOK struct

+ Payload *DcimPlatformsListOKBody

+ func NewDcimPlatformsListOK() *DcimPlatformsListOK

+ func (o *DcimPlatformsListOK) Error() string

+ type DcimPlatformsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Platform

+ func (o *DcimPlatformsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPlatformsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPlatformsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPlatformsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Manufacturer *string

+ ManufacturerID *string

+ Name *string

+ Offset *int64

+ Slug *string

+ func NewDcimPlatformsListParams() *DcimPlatformsListParams

+ func NewDcimPlatformsListParamsWithContext(ctx context.Context) *DcimPlatformsListParams

+ func NewDcimPlatformsListParamsWithHTTPClient(client *http.Client) *DcimPlatformsListParams

+ func NewDcimPlatformsListParamsWithTimeout(timeout time.Duration) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsListParams) SetLimit(limit *int64)

+ func (o *DcimPlatformsListParams) SetManufacturer(manufacturer *string)

+ func (o *DcimPlatformsListParams) SetManufacturerID(manufacturerID *string)

+ func (o *DcimPlatformsListParams) SetName(name *string)

+ func (o *DcimPlatformsListParams) SetOffset(offset *int64)

+ func (o *DcimPlatformsListParams) SetSlug(slug *string)

+ func (o *DcimPlatformsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsListParams) WithContext(ctx context.Context) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithHTTPClient(client *http.Client) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithLimit(limit *int64) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithManufacturer(manufacturer *string) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithManufacturerID(manufacturerID *string) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithName(name *string) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithOffset(offset *int64) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithSlug(slug *string) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WithTimeout(timeout time.Duration) *DcimPlatformsListParams

+ func (o *DcimPlatformsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsListReader struct

+ func (o *DcimPlatformsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsPartialUpdateOK struct

+ Payload *models.Platform

+ func NewDcimPlatformsPartialUpdateOK() *DcimPlatformsPartialUpdateOK

+ func (o *DcimPlatformsPartialUpdateOK) Error() string

+ type DcimPlatformsPartialUpdateParams struct

+ Context context.Context

+ Data *models.Platform

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPlatformsPartialUpdateParams() *DcimPlatformsPartialUpdateParams

+ func NewDcimPlatformsPartialUpdateParamsWithContext(ctx context.Context) *DcimPlatformsPartialUpdateParams

+ func NewDcimPlatformsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimPlatformsPartialUpdateParams

+ func NewDcimPlatformsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsPartialUpdateParams) SetData(data *models.Platform)

+ func (o *DcimPlatformsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsPartialUpdateParams) SetID(id int64)

+ func (o *DcimPlatformsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsPartialUpdateParams) WithContext(ctx context.Context) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) WithData(data *models.Platform) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) WithID(id int64) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimPlatformsPartialUpdateParams

+ func (o *DcimPlatformsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsPartialUpdateReader struct

+ func (o *DcimPlatformsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsReadOK struct

+ Payload *models.Platform

+ func NewDcimPlatformsReadOK() *DcimPlatformsReadOK

+ func (o *DcimPlatformsReadOK) Error() string

+ type DcimPlatformsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPlatformsReadParams() *DcimPlatformsReadParams

+ func NewDcimPlatformsReadParamsWithContext(ctx context.Context) *DcimPlatformsReadParams

+ func NewDcimPlatformsReadParamsWithHTTPClient(client *http.Client) *DcimPlatformsReadParams

+ func NewDcimPlatformsReadParamsWithTimeout(timeout time.Duration) *DcimPlatformsReadParams

+ func (o *DcimPlatformsReadParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsReadParams) SetID(id int64)

+ func (o *DcimPlatformsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsReadParams) WithContext(ctx context.Context) *DcimPlatformsReadParams

+ func (o *DcimPlatformsReadParams) WithHTTPClient(client *http.Client) *DcimPlatformsReadParams

+ func (o *DcimPlatformsReadParams) WithID(id int64) *DcimPlatformsReadParams

+ func (o *DcimPlatformsReadParams) WithTimeout(timeout time.Duration) *DcimPlatformsReadParams

+ func (o *DcimPlatformsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsReadReader struct

+ func (o *DcimPlatformsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPlatformsUpdateOK struct

+ Payload *models.Platform

+ func NewDcimPlatformsUpdateOK() *DcimPlatformsUpdateOK

+ func (o *DcimPlatformsUpdateOK) Error() string

+ type DcimPlatformsUpdateParams struct

+ Context context.Context

+ Data *models.Platform

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPlatformsUpdateParams() *DcimPlatformsUpdateParams

+ func NewDcimPlatformsUpdateParamsWithContext(ctx context.Context) *DcimPlatformsUpdateParams

+ func NewDcimPlatformsUpdateParamsWithHTTPClient(client *http.Client) *DcimPlatformsUpdateParams

+ func NewDcimPlatformsUpdateParamsWithTimeout(timeout time.Duration) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPlatformsUpdateParams) SetData(data *models.Platform)

+ func (o *DcimPlatformsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPlatformsUpdateParams) SetID(id int64)

+ func (o *DcimPlatformsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPlatformsUpdateParams) WithContext(ctx context.Context) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) WithData(data *models.Platform) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) WithHTTPClient(client *http.Client) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) WithID(id int64) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) WithTimeout(timeout time.Duration) *DcimPlatformsUpdateParams

+ func (o *DcimPlatformsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPlatformsUpdateReader struct

+ func (o *DcimPlatformsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerConnectionsListOK struct

+ Payload *DcimPowerConnectionsListOKBody

+ func NewDcimPowerConnectionsListOK() *DcimPowerConnectionsListOK

+ func (o *DcimPowerConnectionsListOK) Error() string

+ type DcimPowerConnectionsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.PowerPort

+ func (o *DcimPowerConnectionsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPowerConnectionsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPowerConnectionsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPowerConnectionsListParams struct

+ ConnectionStatus *string

+ Context context.Context

+ Device *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Site *string

+ func NewDcimPowerConnectionsListParams() *DcimPowerConnectionsListParams

+ func NewDcimPowerConnectionsListParamsWithContext(ctx context.Context) *DcimPowerConnectionsListParams

+ func NewDcimPowerConnectionsListParamsWithHTTPClient(client *http.Client) *DcimPowerConnectionsListParams

+ func NewDcimPowerConnectionsListParamsWithTimeout(timeout time.Duration) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) SetConnectionStatus(connectionStatus *string)

+ func (o *DcimPowerConnectionsListParams) SetContext(ctx context.Context)

+ func (o *DcimPowerConnectionsListParams) SetDevice(device *string)

+ func (o *DcimPowerConnectionsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerConnectionsListParams) SetLimit(limit *int64)

+ func (o *DcimPowerConnectionsListParams) SetName(name *string)

+ func (o *DcimPowerConnectionsListParams) SetOffset(offset *int64)

+ func (o *DcimPowerConnectionsListParams) SetSite(site *string)

+ func (o *DcimPowerConnectionsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerConnectionsListParams) WithConnectionStatus(connectionStatus *string) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithContext(ctx context.Context) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithDevice(device *string) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithHTTPClient(client *http.Client) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithLimit(limit *int64) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithName(name *string) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithOffset(offset *int64) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithSite(site *string) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WithTimeout(timeout time.Duration) *DcimPowerConnectionsListParams

+ func (o *DcimPowerConnectionsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerConnectionsListReader struct

+ func (o *DcimPowerConnectionsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesCreateCreated struct

+ Payload *models.PowerOutletTemplate

+ func NewDcimPowerOutletTemplatesCreateCreated() *DcimPowerOutletTemplatesCreateCreated

+ func (o *DcimPowerOutletTemplatesCreateCreated) Error() string

+ type DcimPowerOutletTemplatesCreateParams struct

+ Context context.Context

+ Data *models.PowerOutletTemplate

+ HTTPClient *http.Client

+ func NewDcimPowerOutletTemplatesCreateParams() *DcimPowerOutletTemplatesCreateParams

+ func NewDcimPowerOutletTemplatesCreateParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesCreateParams

+ func NewDcimPowerOutletTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesCreateParams

+ func NewDcimPowerOutletTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesCreateParams

+ func (o *DcimPowerOutletTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesCreateParams) SetData(data *models.PowerOutletTemplate)

+ func (o *DcimPowerOutletTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesCreateParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesCreateParams

+ func (o *DcimPowerOutletTemplatesCreateParams) WithData(data *models.PowerOutletTemplate) *DcimPowerOutletTemplatesCreateParams

+ func (o *DcimPowerOutletTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesCreateParams

+ func (o *DcimPowerOutletTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesCreateParams

+ func (o *DcimPowerOutletTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesCreateReader struct

+ func (o *DcimPowerOutletTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesDeleteNoContent struct

+ func NewDcimPowerOutletTemplatesDeleteNoContent() *DcimPowerOutletTemplatesDeleteNoContent

+ func (o *DcimPowerOutletTemplatesDeleteNoContent) Error() string

+ type DcimPowerOutletTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletTemplatesDeleteParams() *DcimPowerOutletTemplatesDeleteParams

+ func NewDcimPowerOutletTemplatesDeleteParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesDeleteParams

+ func NewDcimPowerOutletTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesDeleteParams

+ func NewDcimPowerOutletTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesDeleteParams

+ func (o *DcimPowerOutletTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimPowerOutletTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesDeleteParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesDeleteParams

+ func (o *DcimPowerOutletTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesDeleteParams

+ func (o *DcimPowerOutletTemplatesDeleteParams) WithID(id int64) *DcimPowerOutletTemplatesDeleteParams

+ func (o *DcimPowerOutletTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesDeleteParams

+ func (o *DcimPowerOutletTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesDeleteReader struct

+ func (o *DcimPowerOutletTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesListOK struct

+ Payload *DcimPowerOutletTemplatesListOKBody

+ func NewDcimPowerOutletTemplatesListOK() *DcimPowerOutletTemplatesListOK

+ func (o *DcimPowerOutletTemplatesListOK) Error() string

+ type DcimPowerOutletTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.PowerOutletTemplate

+ func (o *DcimPowerOutletTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPowerOutletTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPowerOutletTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPowerOutletTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewDcimPowerOutletTemplatesListParams() *DcimPowerOutletTemplatesListParams

+ func NewDcimPowerOutletTemplatesListParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesListParams

+ func NewDcimPowerOutletTemplatesListParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesListParams

+ func NewDcimPowerOutletTemplatesListParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimPowerOutletTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimPowerOutletTemplatesListParams) SetName(name *string)

+ func (o *DcimPowerOutletTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimPowerOutletTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesListParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithLimit(limit *int64) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithName(name *string) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithOffset(offset *int64) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesListParams

+ func (o *DcimPowerOutletTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesListReader struct

+ func (o *DcimPowerOutletTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesPartialUpdateOK struct

+ Payload *models.PowerOutletTemplate

+ func NewDcimPowerOutletTemplatesPartialUpdateOK() *DcimPowerOutletTemplatesPartialUpdateOK

+ func (o *DcimPowerOutletTemplatesPartialUpdateOK) Error() string

+ type DcimPowerOutletTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.PowerOutletTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletTemplatesPartialUpdateParams() *DcimPowerOutletTemplatesPartialUpdateParams

+ func NewDcimPowerOutletTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesPartialUpdateParams

+ func NewDcimPowerOutletTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesPartialUpdateParams

+ func NewDcimPowerOutletTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) SetData(data *models.PowerOutletTemplate)

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WithData(data *models.PowerOutletTemplate) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WithID(id int64) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesPartialUpdateParams

+ func (o *DcimPowerOutletTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesPartialUpdateReader struct

+ func (o *DcimPowerOutletTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesReadOK struct

+ Payload *models.PowerOutletTemplate

+ func NewDcimPowerOutletTemplatesReadOK() *DcimPowerOutletTemplatesReadOK

+ func (o *DcimPowerOutletTemplatesReadOK) Error() string

+ type DcimPowerOutletTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletTemplatesReadParams() *DcimPowerOutletTemplatesReadParams

+ func NewDcimPowerOutletTemplatesReadParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesReadParams

+ func NewDcimPowerOutletTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesReadParams

+ func NewDcimPowerOutletTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesReadParams

+ func (o *DcimPowerOutletTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesReadParams) SetID(id int64)

+ func (o *DcimPowerOutletTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesReadParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesReadParams

+ func (o *DcimPowerOutletTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesReadParams

+ func (o *DcimPowerOutletTemplatesReadParams) WithID(id int64) *DcimPowerOutletTemplatesReadParams

+ func (o *DcimPowerOutletTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesReadParams

+ func (o *DcimPowerOutletTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesReadReader struct

+ func (o *DcimPowerOutletTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletTemplatesUpdateOK struct

+ Payload *models.PowerOutletTemplate

+ func NewDcimPowerOutletTemplatesUpdateOK() *DcimPowerOutletTemplatesUpdateOK

+ func (o *DcimPowerOutletTemplatesUpdateOK) Error() string

+ type DcimPowerOutletTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.PowerOutletTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletTemplatesUpdateParams() *DcimPowerOutletTemplatesUpdateParams

+ func NewDcimPowerOutletTemplatesUpdateParamsWithContext(ctx context.Context) *DcimPowerOutletTemplatesUpdateParams

+ func NewDcimPowerOutletTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesUpdateParams

+ func NewDcimPowerOutletTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletTemplatesUpdateParams) SetData(data *models.PowerOutletTemplate)

+ func (o *DcimPowerOutletTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimPowerOutletTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletTemplatesUpdateParams) WithContext(ctx context.Context) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) WithData(data *models.PowerOutletTemplate) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) WithID(id int64) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletTemplatesUpdateParams

+ func (o *DcimPowerOutletTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletTemplatesUpdateReader struct

+ func (o *DcimPowerOutletTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsCreateCreated struct

+ Payload *models.PowerOutlet

+ func NewDcimPowerOutletsCreateCreated() *DcimPowerOutletsCreateCreated

+ func (o *DcimPowerOutletsCreateCreated) Error() string

+ type DcimPowerOutletsCreateParams struct

+ Context context.Context

+ Data *models.PowerOutlet

+ HTTPClient *http.Client

+ func NewDcimPowerOutletsCreateParams() *DcimPowerOutletsCreateParams

+ func NewDcimPowerOutletsCreateParamsWithContext(ctx context.Context) *DcimPowerOutletsCreateParams

+ func NewDcimPowerOutletsCreateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsCreateParams

+ func NewDcimPowerOutletsCreateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsCreateParams

+ func (o *DcimPowerOutletsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsCreateParams) SetData(data *models.PowerOutlet)

+ func (o *DcimPowerOutletsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsCreateParams) WithContext(ctx context.Context) *DcimPowerOutletsCreateParams

+ func (o *DcimPowerOutletsCreateParams) WithData(data *models.PowerOutlet) *DcimPowerOutletsCreateParams

+ func (o *DcimPowerOutletsCreateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsCreateParams

+ func (o *DcimPowerOutletsCreateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsCreateParams

+ func (o *DcimPowerOutletsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsCreateReader struct

+ func (o *DcimPowerOutletsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsDeleteNoContent struct

+ func NewDcimPowerOutletsDeleteNoContent() *DcimPowerOutletsDeleteNoContent

+ func (o *DcimPowerOutletsDeleteNoContent) Error() string

+ type DcimPowerOutletsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletsDeleteParams() *DcimPowerOutletsDeleteParams

+ func NewDcimPowerOutletsDeleteParamsWithContext(ctx context.Context) *DcimPowerOutletsDeleteParams

+ func NewDcimPowerOutletsDeleteParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsDeleteParams

+ func NewDcimPowerOutletsDeleteParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsDeleteParams

+ func (o *DcimPowerOutletsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsDeleteParams) SetID(id int64)

+ func (o *DcimPowerOutletsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsDeleteParams) WithContext(ctx context.Context) *DcimPowerOutletsDeleteParams

+ func (o *DcimPowerOutletsDeleteParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsDeleteParams

+ func (o *DcimPowerOutletsDeleteParams) WithID(id int64) *DcimPowerOutletsDeleteParams

+ func (o *DcimPowerOutletsDeleteParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsDeleteParams

+ func (o *DcimPowerOutletsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsDeleteReader struct

+ func (o *DcimPowerOutletsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsListOK struct

+ Payload *DcimPowerOutletsListOKBody

+ func NewDcimPowerOutletsListOK() *DcimPowerOutletsListOK

+ func (o *DcimPowerOutletsListOK) Error() string

+ type DcimPowerOutletsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.PowerOutlet

+ func (o *DcimPowerOutletsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPowerOutletsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPowerOutletsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPowerOutletsListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Tag *string

+ func NewDcimPowerOutletsListParams() *DcimPowerOutletsListParams

+ func NewDcimPowerOutletsListParamsWithContext(ctx context.Context) *DcimPowerOutletsListParams

+ func NewDcimPowerOutletsListParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsListParams

+ func NewDcimPowerOutletsListParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsListParams) SetDevice(device *string)

+ func (o *DcimPowerOutletsListParams) SetDeviceID(deviceID *string)

+ func (o *DcimPowerOutletsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsListParams) SetLimit(limit *int64)

+ func (o *DcimPowerOutletsListParams) SetName(name *string)

+ func (o *DcimPowerOutletsListParams) SetOffset(offset *int64)

+ func (o *DcimPowerOutletsListParams) SetTag(tag *string)

+ func (o *DcimPowerOutletsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsListParams) WithContext(ctx context.Context) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithDevice(device *string) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithDeviceID(deviceID *string) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithLimit(limit *int64) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithName(name *string) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithOffset(offset *int64) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithTag(tag *string) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsListParams

+ func (o *DcimPowerOutletsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsListReader struct

+ func (o *DcimPowerOutletsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsPartialUpdateOK struct

+ Payload *models.PowerOutlet

+ func NewDcimPowerOutletsPartialUpdateOK() *DcimPowerOutletsPartialUpdateOK

+ func (o *DcimPowerOutletsPartialUpdateOK) Error() string

+ type DcimPowerOutletsPartialUpdateParams struct

+ Context context.Context

+ Data *models.PowerOutlet

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletsPartialUpdateParams() *DcimPowerOutletsPartialUpdateParams

+ func NewDcimPowerOutletsPartialUpdateParamsWithContext(ctx context.Context) *DcimPowerOutletsPartialUpdateParams

+ func NewDcimPowerOutletsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsPartialUpdateParams

+ func NewDcimPowerOutletsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsPartialUpdateParams) SetData(data *models.PowerOutlet)

+ func (o *DcimPowerOutletsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsPartialUpdateParams) SetID(id int64)

+ func (o *DcimPowerOutletsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsPartialUpdateParams) WithContext(ctx context.Context) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) WithData(data *models.PowerOutlet) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) WithID(id int64) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsPartialUpdateParams

+ func (o *DcimPowerOutletsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsPartialUpdateReader struct

+ func (o *DcimPowerOutletsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsReadOK struct

+ Payload *models.PowerOutlet

+ func NewDcimPowerOutletsReadOK() *DcimPowerOutletsReadOK

+ func (o *DcimPowerOutletsReadOK) Error() string

+ type DcimPowerOutletsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletsReadParams() *DcimPowerOutletsReadParams

+ func NewDcimPowerOutletsReadParamsWithContext(ctx context.Context) *DcimPowerOutletsReadParams

+ func NewDcimPowerOutletsReadParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsReadParams

+ func NewDcimPowerOutletsReadParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsReadParams

+ func (o *DcimPowerOutletsReadParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsReadParams) SetID(id int64)

+ func (o *DcimPowerOutletsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsReadParams) WithContext(ctx context.Context) *DcimPowerOutletsReadParams

+ func (o *DcimPowerOutletsReadParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsReadParams

+ func (o *DcimPowerOutletsReadParams) WithID(id int64) *DcimPowerOutletsReadParams

+ func (o *DcimPowerOutletsReadParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsReadParams

+ func (o *DcimPowerOutletsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsReadReader struct

+ func (o *DcimPowerOutletsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerOutletsUpdateOK struct

+ Payload *models.PowerOutlet

+ func NewDcimPowerOutletsUpdateOK() *DcimPowerOutletsUpdateOK

+ func (o *DcimPowerOutletsUpdateOK) Error() string

+ type DcimPowerOutletsUpdateParams struct

+ Context context.Context

+ Data *models.PowerOutlet

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerOutletsUpdateParams() *DcimPowerOutletsUpdateParams

+ func NewDcimPowerOutletsUpdateParamsWithContext(ctx context.Context) *DcimPowerOutletsUpdateParams

+ func NewDcimPowerOutletsUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerOutletsUpdateParams

+ func NewDcimPowerOutletsUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerOutletsUpdateParams) SetData(data *models.PowerOutlet)

+ func (o *DcimPowerOutletsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerOutletsUpdateParams) SetID(id int64)

+ func (o *DcimPowerOutletsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerOutletsUpdateParams) WithContext(ctx context.Context) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) WithData(data *models.PowerOutlet) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) WithID(id int64) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerOutletsUpdateParams

+ func (o *DcimPowerOutletsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerOutletsUpdateReader struct

+ func (o *DcimPowerOutletsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesCreateCreated struct

+ Payload *models.PowerPortTemplate

+ func NewDcimPowerPortTemplatesCreateCreated() *DcimPowerPortTemplatesCreateCreated

+ func (o *DcimPowerPortTemplatesCreateCreated) Error() string

+ type DcimPowerPortTemplatesCreateParams struct

+ Context context.Context

+ Data *models.PowerPortTemplate

+ HTTPClient *http.Client

+ func NewDcimPowerPortTemplatesCreateParams() *DcimPowerPortTemplatesCreateParams

+ func NewDcimPowerPortTemplatesCreateParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesCreateParams

+ func NewDcimPowerPortTemplatesCreateParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesCreateParams

+ func NewDcimPowerPortTemplatesCreateParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesCreateParams

+ func (o *DcimPowerPortTemplatesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesCreateParams) SetData(data *models.PowerPortTemplate)

+ func (o *DcimPowerPortTemplatesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesCreateParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesCreateParams

+ func (o *DcimPowerPortTemplatesCreateParams) WithData(data *models.PowerPortTemplate) *DcimPowerPortTemplatesCreateParams

+ func (o *DcimPowerPortTemplatesCreateParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesCreateParams

+ func (o *DcimPowerPortTemplatesCreateParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesCreateParams

+ func (o *DcimPowerPortTemplatesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesCreateReader struct

+ func (o *DcimPowerPortTemplatesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesDeleteNoContent struct

+ func NewDcimPowerPortTemplatesDeleteNoContent() *DcimPowerPortTemplatesDeleteNoContent

+ func (o *DcimPowerPortTemplatesDeleteNoContent) Error() string

+ type DcimPowerPortTemplatesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortTemplatesDeleteParams() *DcimPowerPortTemplatesDeleteParams

+ func NewDcimPowerPortTemplatesDeleteParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesDeleteParams

+ func NewDcimPowerPortTemplatesDeleteParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesDeleteParams

+ func NewDcimPowerPortTemplatesDeleteParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesDeleteParams

+ func (o *DcimPowerPortTemplatesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesDeleteParams) SetID(id int64)

+ func (o *DcimPowerPortTemplatesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesDeleteParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesDeleteParams

+ func (o *DcimPowerPortTemplatesDeleteParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesDeleteParams

+ func (o *DcimPowerPortTemplatesDeleteParams) WithID(id int64) *DcimPowerPortTemplatesDeleteParams

+ func (o *DcimPowerPortTemplatesDeleteParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesDeleteParams

+ func (o *DcimPowerPortTemplatesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesDeleteReader struct

+ func (o *DcimPowerPortTemplatesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesListOK struct

+ Payload *DcimPowerPortTemplatesListOKBody

+ func NewDcimPowerPortTemplatesListOK() *DcimPowerPortTemplatesListOK

+ func (o *DcimPowerPortTemplatesListOK) Error() string

+ type DcimPowerPortTemplatesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.PowerPortTemplate

+ func (o *DcimPowerPortTemplatesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPowerPortTemplatesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPowerPortTemplatesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPowerPortTemplatesListParams struct

+ Context context.Context

+ DevicetypeID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ func NewDcimPowerPortTemplatesListParams() *DcimPowerPortTemplatesListParams

+ func NewDcimPowerPortTemplatesListParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesListParams

+ func NewDcimPowerPortTemplatesListParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesListParams

+ func NewDcimPowerPortTemplatesListParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesListParams) SetDevicetypeID(devicetypeID *string)

+ func (o *DcimPowerPortTemplatesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesListParams) SetLimit(limit *int64)

+ func (o *DcimPowerPortTemplatesListParams) SetName(name *string)

+ func (o *DcimPowerPortTemplatesListParams) SetOffset(offset *int64)

+ func (o *DcimPowerPortTemplatesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesListParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithDevicetypeID(devicetypeID *string) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithLimit(limit *int64) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithName(name *string) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithOffset(offset *int64) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesListParams

+ func (o *DcimPowerPortTemplatesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesListReader struct

+ func (o *DcimPowerPortTemplatesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesPartialUpdateOK struct

+ Payload *models.PowerPortTemplate

+ func NewDcimPowerPortTemplatesPartialUpdateOK() *DcimPowerPortTemplatesPartialUpdateOK

+ func (o *DcimPowerPortTemplatesPartialUpdateOK) Error() string

+ type DcimPowerPortTemplatesPartialUpdateParams struct

+ Context context.Context

+ Data *models.PowerPortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortTemplatesPartialUpdateParams() *DcimPowerPortTemplatesPartialUpdateParams

+ func NewDcimPowerPortTemplatesPartialUpdateParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesPartialUpdateParams

+ func NewDcimPowerPortTemplatesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesPartialUpdateParams

+ func NewDcimPowerPortTemplatesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) SetData(data *models.PowerPortTemplate)

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) SetID(id int64)

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WithData(data *models.PowerPortTemplate) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WithID(id int64) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesPartialUpdateParams

+ func (o *DcimPowerPortTemplatesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesPartialUpdateReader struct

+ func (o *DcimPowerPortTemplatesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesReadOK struct

+ Payload *models.PowerPortTemplate

+ func NewDcimPowerPortTemplatesReadOK() *DcimPowerPortTemplatesReadOK

+ func (o *DcimPowerPortTemplatesReadOK) Error() string

+ type DcimPowerPortTemplatesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortTemplatesReadParams() *DcimPowerPortTemplatesReadParams

+ func NewDcimPowerPortTemplatesReadParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesReadParams

+ func NewDcimPowerPortTemplatesReadParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesReadParams

+ func NewDcimPowerPortTemplatesReadParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesReadParams

+ func (o *DcimPowerPortTemplatesReadParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesReadParams) SetID(id int64)

+ func (o *DcimPowerPortTemplatesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesReadParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesReadParams

+ func (o *DcimPowerPortTemplatesReadParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesReadParams

+ func (o *DcimPowerPortTemplatesReadParams) WithID(id int64) *DcimPowerPortTemplatesReadParams

+ func (o *DcimPowerPortTemplatesReadParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesReadParams

+ func (o *DcimPowerPortTemplatesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesReadReader struct

+ func (o *DcimPowerPortTemplatesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortTemplatesUpdateOK struct

+ Payload *models.PowerPortTemplate

+ func NewDcimPowerPortTemplatesUpdateOK() *DcimPowerPortTemplatesUpdateOK

+ func (o *DcimPowerPortTemplatesUpdateOK) Error() string

+ type DcimPowerPortTemplatesUpdateParams struct

+ Context context.Context

+ Data *models.PowerPortTemplate

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortTemplatesUpdateParams() *DcimPowerPortTemplatesUpdateParams

+ func NewDcimPowerPortTemplatesUpdateParamsWithContext(ctx context.Context) *DcimPowerPortTemplatesUpdateParams

+ func NewDcimPowerPortTemplatesUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerPortTemplatesUpdateParams

+ func NewDcimPowerPortTemplatesUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortTemplatesUpdateParams) SetData(data *models.PowerPortTemplate)

+ func (o *DcimPowerPortTemplatesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortTemplatesUpdateParams) SetID(id int64)

+ func (o *DcimPowerPortTemplatesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortTemplatesUpdateParams) WithContext(ctx context.Context) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) WithData(data *models.PowerPortTemplate) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) WithID(id int64) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerPortTemplatesUpdateParams

+ func (o *DcimPowerPortTemplatesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortTemplatesUpdateReader struct

+ func (o *DcimPowerPortTemplatesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsCreateCreated struct

+ Payload *models.PowerPort

+ func NewDcimPowerPortsCreateCreated() *DcimPowerPortsCreateCreated

+ func (o *DcimPowerPortsCreateCreated) Error() string

+ type DcimPowerPortsCreateParams struct

+ Context context.Context

+ Data *models.PowerPort

+ HTTPClient *http.Client

+ func NewDcimPowerPortsCreateParams() *DcimPowerPortsCreateParams

+ func NewDcimPowerPortsCreateParamsWithContext(ctx context.Context) *DcimPowerPortsCreateParams

+ func NewDcimPowerPortsCreateParamsWithHTTPClient(client *http.Client) *DcimPowerPortsCreateParams

+ func NewDcimPowerPortsCreateParamsWithTimeout(timeout time.Duration) *DcimPowerPortsCreateParams

+ func (o *DcimPowerPortsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsCreateParams) SetData(data *models.PowerPort)

+ func (o *DcimPowerPortsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsCreateParams) WithContext(ctx context.Context) *DcimPowerPortsCreateParams

+ func (o *DcimPowerPortsCreateParams) WithData(data *models.PowerPort) *DcimPowerPortsCreateParams

+ func (o *DcimPowerPortsCreateParams) WithHTTPClient(client *http.Client) *DcimPowerPortsCreateParams

+ func (o *DcimPowerPortsCreateParams) WithTimeout(timeout time.Duration) *DcimPowerPortsCreateParams

+ func (o *DcimPowerPortsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsCreateReader struct

+ func (o *DcimPowerPortsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsDeleteNoContent struct

+ func NewDcimPowerPortsDeleteNoContent() *DcimPowerPortsDeleteNoContent

+ func (o *DcimPowerPortsDeleteNoContent) Error() string

+ type DcimPowerPortsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortsDeleteParams() *DcimPowerPortsDeleteParams

+ func NewDcimPowerPortsDeleteParamsWithContext(ctx context.Context) *DcimPowerPortsDeleteParams

+ func NewDcimPowerPortsDeleteParamsWithHTTPClient(client *http.Client) *DcimPowerPortsDeleteParams

+ func NewDcimPowerPortsDeleteParamsWithTimeout(timeout time.Duration) *DcimPowerPortsDeleteParams

+ func (o *DcimPowerPortsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsDeleteParams) SetID(id int64)

+ func (o *DcimPowerPortsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsDeleteParams) WithContext(ctx context.Context) *DcimPowerPortsDeleteParams

+ func (o *DcimPowerPortsDeleteParams) WithHTTPClient(client *http.Client) *DcimPowerPortsDeleteParams

+ func (o *DcimPowerPortsDeleteParams) WithID(id int64) *DcimPowerPortsDeleteParams

+ func (o *DcimPowerPortsDeleteParams) WithTimeout(timeout time.Duration) *DcimPowerPortsDeleteParams

+ func (o *DcimPowerPortsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsDeleteReader struct

+ func (o *DcimPowerPortsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsListOK struct

+ Payload *DcimPowerPortsListOKBody

+ func NewDcimPowerPortsListOK() *DcimPowerPortsListOK

+ func (o *DcimPowerPortsListOK) Error() string

+ type DcimPowerPortsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.PowerPort

+ func (o *DcimPowerPortsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimPowerPortsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimPowerPortsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimPowerPortsListParams struct

+ Context context.Context

+ Device *string

+ DeviceID *string

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Tag *string

+ func NewDcimPowerPortsListParams() *DcimPowerPortsListParams

+ func NewDcimPowerPortsListParamsWithContext(ctx context.Context) *DcimPowerPortsListParams

+ func NewDcimPowerPortsListParamsWithHTTPClient(client *http.Client) *DcimPowerPortsListParams

+ func NewDcimPowerPortsListParamsWithTimeout(timeout time.Duration) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsListParams) SetDevice(device *string)

+ func (o *DcimPowerPortsListParams) SetDeviceID(deviceID *string)

+ func (o *DcimPowerPortsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsListParams) SetLimit(limit *int64)

+ func (o *DcimPowerPortsListParams) SetName(name *string)

+ func (o *DcimPowerPortsListParams) SetOffset(offset *int64)

+ func (o *DcimPowerPortsListParams) SetTag(tag *string)

+ func (o *DcimPowerPortsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsListParams) WithContext(ctx context.Context) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithDevice(device *string) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithDeviceID(deviceID *string) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithHTTPClient(client *http.Client) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithLimit(limit *int64) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithName(name *string) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithOffset(offset *int64) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithTag(tag *string) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WithTimeout(timeout time.Duration) *DcimPowerPortsListParams

+ func (o *DcimPowerPortsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsListReader struct

+ func (o *DcimPowerPortsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsPartialUpdateOK struct

+ Payload *models.PowerPort

+ func NewDcimPowerPortsPartialUpdateOK() *DcimPowerPortsPartialUpdateOK

+ func (o *DcimPowerPortsPartialUpdateOK) Error() string

+ type DcimPowerPortsPartialUpdateParams struct

+ Context context.Context

+ Data *models.PowerPort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortsPartialUpdateParams() *DcimPowerPortsPartialUpdateParams

+ func NewDcimPowerPortsPartialUpdateParamsWithContext(ctx context.Context) *DcimPowerPortsPartialUpdateParams

+ func NewDcimPowerPortsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerPortsPartialUpdateParams

+ func NewDcimPowerPortsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsPartialUpdateParams) SetData(data *models.PowerPort)

+ func (o *DcimPowerPortsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsPartialUpdateParams) SetID(id int64)

+ func (o *DcimPowerPortsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsPartialUpdateParams) WithContext(ctx context.Context) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) WithData(data *models.PowerPort) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) WithID(id int64) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerPortsPartialUpdateParams

+ func (o *DcimPowerPortsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsPartialUpdateReader struct

+ func (o *DcimPowerPortsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsReadOK struct

+ Payload *models.PowerPort

+ func NewDcimPowerPortsReadOK() *DcimPowerPortsReadOK

+ func (o *DcimPowerPortsReadOK) Error() string

+ type DcimPowerPortsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortsReadParams() *DcimPowerPortsReadParams

+ func NewDcimPowerPortsReadParamsWithContext(ctx context.Context) *DcimPowerPortsReadParams

+ func NewDcimPowerPortsReadParamsWithHTTPClient(client *http.Client) *DcimPowerPortsReadParams

+ func NewDcimPowerPortsReadParamsWithTimeout(timeout time.Duration) *DcimPowerPortsReadParams

+ func (o *DcimPowerPortsReadParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsReadParams) SetID(id int64)

+ func (o *DcimPowerPortsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsReadParams) WithContext(ctx context.Context) *DcimPowerPortsReadParams

+ func (o *DcimPowerPortsReadParams) WithHTTPClient(client *http.Client) *DcimPowerPortsReadParams

+ func (o *DcimPowerPortsReadParams) WithID(id int64) *DcimPowerPortsReadParams

+ func (o *DcimPowerPortsReadParams) WithTimeout(timeout time.Duration) *DcimPowerPortsReadParams

+ func (o *DcimPowerPortsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsReadReader struct

+ func (o *DcimPowerPortsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimPowerPortsUpdateOK struct

+ Payload *models.PowerPort

+ func NewDcimPowerPortsUpdateOK() *DcimPowerPortsUpdateOK

+ func (o *DcimPowerPortsUpdateOK) Error() string

+ type DcimPowerPortsUpdateParams struct

+ Context context.Context

+ Data *models.PowerPort

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimPowerPortsUpdateParams() *DcimPowerPortsUpdateParams

+ func NewDcimPowerPortsUpdateParamsWithContext(ctx context.Context) *DcimPowerPortsUpdateParams

+ func NewDcimPowerPortsUpdateParamsWithHTTPClient(client *http.Client) *DcimPowerPortsUpdateParams

+ func NewDcimPowerPortsUpdateParamsWithTimeout(timeout time.Duration) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimPowerPortsUpdateParams) SetData(data *models.PowerPort)

+ func (o *DcimPowerPortsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimPowerPortsUpdateParams) SetID(id int64)

+ func (o *DcimPowerPortsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimPowerPortsUpdateParams) WithContext(ctx context.Context) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) WithData(data *models.PowerPort) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) WithHTTPClient(client *http.Client) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) WithID(id int64) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) WithTimeout(timeout time.Duration) *DcimPowerPortsUpdateParams

+ func (o *DcimPowerPortsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimPowerPortsUpdateReader struct

+ func (o *DcimPowerPortsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsCreateCreated struct

+ Payload *models.RackGroup

+ func NewDcimRackGroupsCreateCreated() *DcimRackGroupsCreateCreated

+ func (o *DcimRackGroupsCreateCreated) Error() string

+ type DcimRackGroupsCreateParams struct

+ Context context.Context

+ Data *models.RackGroup

+ HTTPClient *http.Client

+ func NewDcimRackGroupsCreateParams() *DcimRackGroupsCreateParams

+ func NewDcimRackGroupsCreateParamsWithContext(ctx context.Context) *DcimRackGroupsCreateParams

+ func NewDcimRackGroupsCreateParamsWithHTTPClient(client *http.Client) *DcimRackGroupsCreateParams

+ func NewDcimRackGroupsCreateParamsWithTimeout(timeout time.Duration) *DcimRackGroupsCreateParams

+ func (o *DcimRackGroupsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsCreateParams) SetData(data *models.RackGroup)

+ func (o *DcimRackGroupsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsCreateParams) WithContext(ctx context.Context) *DcimRackGroupsCreateParams

+ func (o *DcimRackGroupsCreateParams) WithData(data *models.RackGroup) *DcimRackGroupsCreateParams

+ func (o *DcimRackGroupsCreateParams) WithHTTPClient(client *http.Client) *DcimRackGroupsCreateParams

+ func (o *DcimRackGroupsCreateParams) WithTimeout(timeout time.Duration) *DcimRackGroupsCreateParams

+ func (o *DcimRackGroupsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsCreateReader struct

+ func (o *DcimRackGroupsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsDeleteNoContent struct

+ func NewDcimRackGroupsDeleteNoContent() *DcimRackGroupsDeleteNoContent

+ func (o *DcimRackGroupsDeleteNoContent) Error() string

+ type DcimRackGroupsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackGroupsDeleteParams() *DcimRackGroupsDeleteParams

+ func NewDcimRackGroupsDeleteParamsWithContext(ctx context.Context) *DcimRackGroupsDeleteParams

+ func NewDcimRackGroupsDeleteParamsWithHTTPClient(client *http.Client) *DcimRackGroupsDeleteParams

+ func NewDcimRackGroupsDeleteParamsWithTimeout(timeout time.Duration) *DcimRackGroupsDeleteParams

+ func (o *DcimRackGroupsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsDeleteParams) SetID(id int64)

+ func (o *DcimRackGroupsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsDeleteParams) WithContext(ctx context.Context) *DcimRackGroupsDeleteParams

+ func (o *DcimRackGroupsDeleteParams) WithHTTPClient(client *http.Client) *DcimRackGroupsDeleteParams

+ func (o *DcimRackGroupsDeleteParams) WithID(id int64) *DcimRackGroupsDeleteParams

+ func (o *DcimRackGroupsDeleteParams) WithTimeout(timeout time.Duration) *DcimRackGroupsDeleteParams

+ func (o *DcimRackGroupsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsDeleteReader struct

+ func (o *DcimRackGroupsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsListOK struct

+ Payload *DcimRackGroupsListOKBody

+ func NewDcimRackGroupsListOK() *DcimRackGroupsListOK

+ func (o *DcimRackGroupsListOK) Error() string

+ type DcimRackGroupsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.RackGroup

+ func (o *DcimRackGroupsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimRackGroupsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimRackGroupsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimRackGroupsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Q *string

+ Site *string

+ SiteID *string

+ Slug *string

+ func NewDcimRackGroupsListParams() *DcimRackGroupsListParams

+ func NewDcimRackGroupsListParamsWithContext(ctx context.Context) *DcimRackGroupsListParams

+ func NewDcimRackGroupsListParamsWithHTTPClient(client *http.Client) *DcimRackGroupsListParams

+ func NewDcimRackGroupsListParamsWithTimeout(timeout time.Duration) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsListParams) SetLimit(limit *int64)

+ func (o *DcimRackGroupsListParams) SetName(name *string)

+ func (o *DcimRackGroupsListParams) SetOffset(offset *int64)

+ func (o *DcimRackGroupsListParams) SetQ(q *string)

+ func (o *DcimRackGroupsListParams) SetSite(site *string)

+ func (o *DcimRackGroupsListParams) SetSiteID(siteID *string)

+ func (o *DcimRackGroupsListParams) SetSlug(slug *string)

+ func (o *DcimRackGroupsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsListParams) WithContext(ctx context.Context) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithHTTPClient(client *http.Client) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithLimit(limit *int64) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithName(name *string) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithOffset(offset *int64) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithQ(q *string) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithSite(site *string) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithSiteID(siteID *string) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithSlug(slug *string) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WithTimeout(timeout time.Duration) *DcimRackGroupsListParams

+ func (o *DcimRackGroupsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsListReader struct

+ func (o *DcimRackGroupsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsPartialUpdateOK struct

+ Payload *models.RackGroup

+ func NewDcimRackGroupsPartialUpdateOK() *DcimRackGroupsPartialUpdateOK

+ func (o *DcimRackGroupsPartialUpdateOK) Error() string

+ type DcimRackGroupsPartialUpdateParams struct

+ Context context.Context

+ Data *models.RackGroup

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackGroupsPartialUpdateParams() *DcimRackGroupsPartialUpdateParams

+ func NewDcimRackGroupsPartialUpdateParamsWithContext(ctx context.Context) *DcimRackGroupsPartialUpdateParams

+ func NewDcimRackGroupsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimRackGroupsPartialUpdateParams

+ func NewDcimRackGroupsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsPartialUpdateParams) SetData(data *models.RackGroup)

+ func (o *DcimRackGroupsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsPartialUpdateParams) SetID(id int64)

+ func (o *DcimRackGroupsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsPartialUpdateParams) WithContext(ctx context.Context) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) WithData(data *models.RackGroup) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) WithID(id int64) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimRackGroupsPartialUpdateParams

+ func (o *DcimRackGroupsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsPartialUpdateReader struct

+ func (o *DcimRackGroupsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsReadOK struct

+ Payload *models.RackGroup

+ func NewDcimRackGroupsReadOK() *DcimRackGroupsReadOK

+ func (o *DcimRackGroupsReadOK) Error() string

+ type DcimRackGroupsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackGroupsReadParams() *DcimRackGroupsReadParams

+ func NewDcimRackGroupsReadParamsWithContext(ctx context.Context) *DcimRackGroupsReadParams

+ func NewDcimRackGroupsReadParamsWithHTTPClient(client *http.Client) *DcimRackGroupsReadParams

+ func NewDcimRackGroupsReadParamsWithTimeout(timeout time.Duration) *DcimRackGroupsReadParams

+ func (o *DcimRackGroupsReadParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsReadParams) SetID(id int64)

+ func (o *DcimRackGroupsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsReadParams) WithContext(ctx context.Context) *DcimRackGroupsReadParams

+ func (o *DcimRackGroupsReadParams) WithHTTPClient(client *http.Client) *DcimRackGroupsReadParams

+ func (o *DcimRackGroupsReadParams) WithID(id int64) *DcimRackGroupsReadParams

+ func (o *DcimRackGroupsReadParams) WithTimeout(timeout time.Duration) *DcimRackGroupsReadParams

+ func (o *DcimRackGroupsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsReadReader struct

+ func (o *DcimRackGroupsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackGroupsUpdateOK struct

+ Payload *models.RackGroup

+ func NewDcimRackGroupsUpdateOK() *DcimRackGroupsUpdateOK

+ func (o *DcimRackGroupsUpdateOK) Error() string

+ type DcimRackGroupsUpdateParams struct

+ Context context.Context

+ Data *models.RackGroup

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackGroupsUpdateParams() *DcimRackGroupsUpdateParams

+ func NewDcimRackGroupsUpdateParamsWithContext(ctx context.Context) *DcimRackGroupsUpdateParams

+ func NewDcimRackGroupsUpdateParamsWithHTTPClient(client *http.Client) *DcimRackGroupsUpdateParams

+ func NewDcimRackGroupsUpdateParamsWithTimeout(timeout time.Duration) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackGroupsUpdateParams) SetData(data *models.RackGroup)

+ func (o *DcimRackGroupsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackGroupsUpdateParams) SetID(id int64)

+ func (o *DcimRackGroupsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackGroupsUpdateParams) WithContext(ctx context.Context) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) WithData(data *models.RackGroup) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) WithHTTPClient(client *http.Client) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) WithID(id int64) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) WithTimeout(timeout time.Duration) *DcimRackGroupsUpdateParams

+ func (o *DcimRackGroupsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackGroupsUpdateReader struct

+ func (o *DcimRackGroupsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsCreateCreated struct

+ Payload *models.RackReservation

+ func NewDcimRackReservationsCreateCreated() *DcimRackReservationsCreateCreated

+ func (o *DcimRackReservationsCreateCreated) Error() string

+ type DcimRackReservationsCreateParams struct

+ Context context.Context

+ Data *models.RackReservation

+ HTTPClient *http.Client

+ func NewDcimRackReservationsCreateParams() *DcimRackReservationsCreateParams

+ func NewDcimRackReservationsCreateParamsWithContext(ctx context.Context) *DcimRackReservationsCreateParams

+ func NewDcimRackReservationsCreateParamsWithHTTPClient(client *http.Client) *DcimRackReservationsCreateParams

+ func NewDcimRackReservationsCreateParamsWithTimeout(timeout time.Duration) *DcimRackReservationsCreateParams

+ func (o *DcimRackReservationsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsCreateParams) SetData(data *models.RackReservation)

+ func (o *DcimRackReservationsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsCreateParams) WithContext(ctx context.Context) *DcimRackReservationsCreateParams

+ func (o *DcimRackReservationsCreateParams) WithData(data *models.RackReservation) *DcimRackReservationsCreateParams

+ func (o *DcimRackReservationsCreateParams) WithHTTPClient(client *http.Client) *DcimRackReservationsCreateParams

+ func (o *DcimRackReservationsCreateParams) WithTimeout(timeout time.Duration) *DcimRackReservationsCreateParams

+ func (o *DcimRackReservationsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsCreateReader struct

+ func (o *DcimRackReservationsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsDeleteNoContent struct

+ func NewDcimRackReservationsDeleteNoContent() *DcimRackReservationsDeleteNoContent

+ func (o *DcimRackReservationsDeleteNoContent) Error() string

+ type DcimRackReservationsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackReservationsDeleteParams() *DcimRackReservationsDeleteParams

+ func NewDcimRackReservationsDeleteParamsWithContext(ctx context.Context) *DcimRackReservationsDeleteParams

+ func NewDcimRackReservationsDeleteParamsWithHTTPClient(client *http.Client) *DcimRackReservationsDeleteParams

+ func NewDcimRackReservationsDeleteParamsWithTimeout(timeout time.Duration) *DcimRackReservationsDeleteParams

+ func (o *DcimRackReservationsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsDeleteParams) SetID(id int64)

+ func (o *DcimRackReservationsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsDeleteParams) WithContext(ctx context.Context) *DcimRackReservationsDeleteParams

+ func (o *DcimRackReservationsDeleteParams) WithHTTPClient(client *http.Client) *DcimRackReservationsDeleteParams

+ func (o *DcimRackReservationsDeleteParams) WithID(id int64) *DcimRackReservationsDeleteParams

+ func (o *DcimRackReservationsDeleteParams) WithTimeout(timeout time.Duration) *DcimRackReservationsDeleteParams

+ func (o *DcimRackReservationsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsDeleteReader struct

+ func (o *DcimRackReservationsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsListOK struct

+ Payload *DcimRackReservationsListOKBody

+ func NewDcimRackReservationsListOK() *DcimRackReservationsListOK

+ func (o *DcimRackReservationsListOK) Error() string

+ type DcimRackReservationsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.RackReservation

+ func (o *DcimRackReservationsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimRackReservationsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimRackReservationsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimRackReservationsListParams struct

+ Context context.Context

+ Created *string

+ Group *string

+ GroupID *string

+ HTTPClient *http.Client

+ IDIn *string

+ Limit *int64

+ Offset *int64

+ Q *string

+ RackID *string

+ Site *string

+ SiteID *string

+ Tenant *string

+ TenantID *string

+ User *string

+ UserID *string

+ func NewDcimRackReservationsListParams() *DcimRackReservationsListParams

+ func NewDcimRackReservationsListParamsWithContext(ctx context.Context) *DcimRackReservationsListParams

+ func NewDcimRackReservationsListParamsWithHTTPClient(client *http.Client) *DcimRackReservationsListParams

+ func NewDcimRackReservationsListParamsWithTimeout(timeout time.Duration) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsListParams) SetCreated(created *string)

+ func (o *DcimRackReservationsListParams) SetGroup(group *string)

+ func (o *DcimRackReservationsListParams) SetGroupID(groupID *string)

+ func (o *DcimRackReservationsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsListParams) SetIDIn(iDIn *string)

+ func (o *DcimRackReservationsListParams) SetLimit(limit *int64)

+ func (o *DcimRackReservationsListParams) SetOffset(offset *int64)

+ func (o *DcimRackReservationsListParams) SetQ(q *string)

+ func (o *DcimRackReservationsListParams) SetRackID(rackID *string)

+ func (o *DcimRackReservationsListParams) SetSite(site *string)

+ func (o *DcimRackReservationsListParams) SetSiteID(siteID *string)

+ func (o *DcimRackReservationsListParams) SetTenant(tenant *string)

+ func (o *DcimRackReservationsListParams) SetTenantID(tenantID *string)

+ func (o *DcimRackReservationsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsListParams) SetUser(user *string)

+ func (o *DcimRackReservationsListParams) SetUserID(userID *string)

+ func (o *DcimRackReservationsListParams) WithContext(ctx context.Context) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithCreated(created *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithGroup(group *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithGroupID(groupID *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithHTTPClient(client *http.Client) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithIDIn(iDIn *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithLimit(limit *int64) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithOffset(offset *int64) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithQ(q *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithRackID(rackID *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithSite(site *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithSiteID(siteID *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithTenant(tenant *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithTenantID(tenantID *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithTimeout(timeout time.Duration) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithUser(user *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WithUserID(userID *string) *DcimRackReservationsListParams

+ func (o *DcimRackReservationsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsListReader struct

+ func (o *DcimRackReservationsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsPartialUpdateOK struct

+ Payload *models.RackReservation

+ func NewDcimRackReservationsPartialUpdateOK() *DcimRackReservationsPartialUpdateOK

+ func (o *DcimRackReservationsPartialUpdateOK) Error() string

+ type DcimRackReservationsPartialUpdateParams struct

+ Context context.Context

+ Data *models.RackReservation

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackReservationsPartialUpdateParams() *DcimRackReservationsPartialUpdateParams

+ func NewDcimRackReservationsPartialUpdateParamsWithContext(ctx context.Context) *DcimRackReservationsPartialUpdateParams

+ func NewDcimRackReservationsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimRackReservationsPartialUpdateParams

+ func NewDcimRackReservationsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsPartialUpdateParams) SetData(data *models.RackReservation)

+ func (o *DcimRackReservationsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsPartialUpdateParams) SetID(id int64)

+ func (o *DcimRackReservationsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsPartialUpdateParams) WithContext(ctx context.Context) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) WithData(data *models.RackReservation) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) WithID(id int64) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimRackReservationsPartialUpdateParams

+ func (o *DcimRackReservationsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsPartialUpdateReader struct

+ func (o *DcimRackReservationsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsReadOK struct

+ Payload *models.RackReservation

+ func NewDcimRackReservationsReadOK() *DcimRackReservationsReadOK

+ func (o *DcimRackReservationsReadOK) Error() string

+ type DcimRackReservationsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackReservationsReadParams() *DcimRackReservationsReadParams

+ func NewDcimRackReservationsReadParamsWithContext(ctx context.Context) *DcimRackReservationsReadParams

+ func NewDcimRackReservationsReadParamsWithHTTPClient(client *http.Client) *DcimRackReservationsReadParams

+ func NewDcimRackReservationsReadParamsWithTimeout(timeout time.Duration) *DcimRackReservationsReadParams

+ func (o *DcimRackReservationsReadParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsReadParams) SetID(id int64)

+ func (o *DcimRackReservationsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsReadParams) WithContext(ctx context.Context) *DcimRackReservationsReadParams

+ func (o *DcimRackReservationsReadParams) WithHTTPClient(client *http.Client) *DcimRackReservationsReadParams

+ func (o *DcimRackReservationsReadParams) WithID(id int64) *DcimRackReservationsReadParams

+ func (o *DcimRackReservationsReadParams) WithTimeout(timeout time.Duration) *DcimRackReservationsReadParams

+ func (o *DcimRackReservationsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsReadReader struct

+ func (o *DcimRackReservationsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackReservationsUpdateOK struct

+ Payload *models.RackReservation

+ func NewDcimRackReservationsUpdateOK() *DcimRackReservationsUpdateOK

+ func (o *DcimRackReservationsUpdateOK) Error() string

+ type DcimRackReservationsUpdateParams struct

+ Context context.Context

+ Data *models.RackReservation

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackReservationsUpdateParams() *DcimRackReservationsUpdateParams

+ func NewDcimRackReservationsUpdateParamsWithContext(ctx context.Context) *DcimRackReservationsUpdateParams

+ func NewDcimRackReservationsUpdateParamsWithHTTPClient(client *http.Client) *DcimRackReservationsUpdateParams

+ func NewDcimRackReservationsUpdateParamsWithTimeout(timeout time.Duration) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackReservationsUpdateParams) SetData(data *models.RackReservation)

+ func (o *DcimRackReservationsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackReservationsUpdateParams) SetID(id int64)

+ func (o *DcimRackReservationsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackReservationsUpdateParams) WithContext(ctx context.Context) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) WithData(data *models.RackReservation) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) WithHTTPClient(client *http.Client) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) WithID(id int64) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) WithTimeout(timeout time.Duration) *DcimRackReservationsUpdateParams

+ func (o *DcimRackReservationsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackReservationsUpdateReader struct

+ func (o *DcimRackReservationsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesCreateCreated struct

+ Payload *models.RackRole

+ func NewDcimRackRolesCreateCreated() *DcimRackRolesCreateCreated

+ func (o *DcimRackRolesCreateCreated) Error() string

+ type DcimRackRolesCreateParams struct

+ Context context.Context

+ Data *models.RackRole

+ HTTPClient *http.Client

+ func NewDcimRackRolesCreateParams() *DcimRackRolesCreateParams

+ func NewDcimRackRolesCreateParamsWithContext(ctx context.Context) *DcimRackRolesCreateParams

+ func NewDcimRackRolesCreateParamsWithHTTPClient(client *http.Client) *DcimRackRolesCreateParams

+ func NewDcimRackRolesCreateParamsWithTimeout(timeout time.Duration) *DcimRackRolesCreateParams

+ func (o *DcimRackRolesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesCreateParams) SetData(data *models.RackRole)

+ func (o *DcimRackRolesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesCreateParams) WithContext(ctx context.Context) *DcimRackRolesCreateParams

+ func (o *DcimRackRolesCreateParams) WithData(data *models.RackRole) *DcimRackRolesCreateParams

+ func (o *DcimRackRolesCreateParams) WithHTTPClient(client *http.Client) *DcimRackRolesCreateParams

+ func (o *DcimRackRolesCreateParams) WithTimeout(timeout time.Duration) *DcimRackRolesCreateParams

+ func (o *DcimRackRolesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesCreateReader struct

+ func (o *DcimRackRolesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesDeleteNoContent struct

+ func NewDcimRackRolesDeleteNoContent() *DcimRackRolesDeleteNoContent

+ func (o *DcimRackRolesDeleteNoContent) Error() string

+ type DcimRackRolesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackRolesDeleteParams() *DcimRackRolesDeleteParams

+ func NewDcimRackRolesDeleteParamsWithContext(ctx context.Context) *DcimRackRolesDeleteParams

+ func NewDcimRackRolesDeleteParamsWithHTTPClient(client *http.Client) *DcimRackRolesDeleteParams

+ func NewDcimRackRolesDeleteParamsWithTimeout(timeout time.Duration) *DcimRackRolesDeleteParams

+ func (o *DcimRackRolesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesDeleteParams) SetID(id int64)

+ func (o *DcimRackRolesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesDeleteParams) WithContext(ctx context.Context) *DcimRackRolesDeleteParams

+ func (o *DcimRackRolesDeleteParams) WithHTTPClient(client *http.Client) *DcimRackRolesDeleteParams

+ func (o *DcimRackRolesDeleteParams) WithID(id int64) *DcimRackRolesDeleteParams

+ func (o *DcimRackRolesDeleteParams) WithTimeout(timeout time.Duration) *DcimRackRolesDeleteParams

+ func (o *DcimRackRolesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesDeleteReader struct

+ func (o *DcimRackRolesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesListOK struct

+ Payload *DcimRackRolesListOKBody

+ func NewDcimRackRolesListOK() *DcimRackRolesListOK

+ func (o *DcimRackRolesListOK) Error() string

+ type DcimRackRolesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.RackRole

+ func (o *DcimRackRolesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimRackRolesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimRackRolesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimRackRolesListParams struct

+ Color *string

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Slug *string

+ func NewDcimRackRolesListParams() *DcimRackRolesListParams

+ func NewDcimRackRolesListParamsWithContext(ctx context.Context) *DcimRackRolesListParams

+ func NewDcimRackRolesListParamsWithHTTPClient(client *http.Client) *DcimRackRolesListParams

+ func NewDcimRackRolesListParamsWithTimeout(timeout time.Duration) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) SetColor(color *string)

+ func (o *DcimRackRolesListParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesListParams) SetLimit(limit *int64)

+ func (o *DcimRackRolesListParams) SetName(name *string)

+ func (o *DcimRackRolesListParams) SetOffset(offset *int64)

+ func (o *DcimRackRolesListParams) SetSlug(slug *string)

+ func (o *DcimRackRolesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesListParams) WithColor(color *string) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithContext(ctx context.Context) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithHTTPClient(client *http.Client) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithLimit(limit *int64) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithName(name *string) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithOffset(offset *int64) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithSlug(slug *string) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WithTimeout(timeout time.Duration) *DcimRackRolesListParams

+ func (o *DcimRackRolesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesListReader struct

+ func (o *DcimRackRolesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesPartialUpdateOK struct

+ Payload *models.RackRole

+ func NewDcimRackRolesPartialUpdateOK() *DcimRackRolesPartialUpdateOK

+ func (o *DcimRackRolesPartialUpdateOK) Error() string

+ type DcimRackRolesPartialUpdateParams struct

+ Context context.Context

+ Data *models.RackRole

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackRolesPartialUpdateParams() *DcimRackRolesPartialUpdateParams

+ func NewDcimRackRolesPartialUpdateParamsWithContext(ctx context.Context) *DcimRackRolesPartialUpdateParams

+ func NewDcimRackRolesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimRackRolesPartialUpdateParams

+ func NewDcimRackRolesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesPartialUpdateParams) SetData(data *models.RackRole)

+ func (o *DcimRackRolesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesPartialUpdateParams) SetID(id int64)

+ func (o *DcimRackRolesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesPartialUpdateParams) WithContext(ctx context.Context) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) WithData(data *models.RackRole) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) WithID(id int64) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimRackRolesPartialUpdateParams

+ func (o *DcimRackRolesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesPartialUpdateReader struct

+ func (o *DcimRackRolesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesReadOK struct

+ Payload *models.RackRole

+ func NewDcimRackRolesReadOK() *DcimRackRolesReadOK

+ func (o *DcimRackRolesReadOK) Error() string

+ type DcimRackRolesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackRolesReadParams() *DcimRackRolesReadParams

+ func NewDcimRackRolesReadParamsWithContext(ctx context.Context) *DcimRackRolesReadParams

+ func NewDcimRackRolesReadParamsWithHTTPClient(client *http.Client) *DcimRackRolesReadParams

+ func NewDcimRackRolesReadParamsWithTimeout(timeout time.Duration) *DcimRackRolesReadParams

+ func (o *DcimRackRolesReadParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesReadParams) SetID(id int64)

+ func (o *DcimRackRolesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesReadParams) WithContext(ctx context.Context) *DcimRackRolesReadParams

+ func (o *DcimRackRolesReadParams) WithHTTPClient(client *http.Client) *DcimRackRolesReadParams

+ func (o *DcimRackRolesReadParams) WithID(id int64) *DcimRackRolesReadParams

+ func (o *DcimRackRolesReadParams) WithTimeout(timeout time.Duration) *DcimRackRolesReadParams

+ func (o *DcimRackRolesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesReadReader struct

+ func (o *DcimRackRolesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRackRolesUpdateOK struct

+ Payload *models.RackRole

+ func NewDcimRackRolesUpdateOK() *DcimRackRolesUpdateOK

+ func (o *DcimRackRolesUpdateOK) Error() string

+ type DcimRackRolesUpdateParams struct

+ Context context.Context

+ Data *models.RackRole

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRackRolesUpdateParams() *DcimRackRolesUpdateParams

+ func NewDcimRackRolesUpdateParamsWithContext(ctx context.Context) *DcimRackRolesUpdateParams

+ func NewDcimRackRolesUpdateParamsWithHTTPClient(client *http.Client) *DcimRackRolesUpdateParams

+ func NewDcimRackRolesUpdateParamsWithTimeout(timeout time.Duration) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRackRolesUpdateParams) SetData(data *models.RackRole)

+ func (o *DcimRackRolesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRackRolesUpdateParams) SetID(id int64)

+ func (o *DcimRackRolesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRackRolesUpdateParams) WithContext(ctx context.Context) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) WithData(data *models.RackRole) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) WithHTTPClient(client *http.Client) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) WithID(id int64) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) WithTimeout(timeout time.Duration) *DcimRackRolesUpdateParams

+ func (o *DcimRackRolesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRackRolesUpdateReader struct

+ func (o *DcimRackRolesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksCreateCreated struct

+ Payload *models.Rack

+ func NewDcimRacksCreateCreated() *DcimRacksCreateCreated

+ func (o *DcimRacksCreateCreated) Error() string

+ type DcimRacksCreateParams struct

+ Context context.Context

+ Data *models.Rack

+ HTTPClient *http.Client

+ func NewDcimRacksCreateParams() *DcimRacksCreateParams

+ func NewDcimRacksCreateParamsWithContext(ctx context.Context) *DcimRacksCreateParams

+ func NewDcimRacksCreateParamsWithHTTPClient(client *http.Client) *DcimRacksCreateParams

+ func NewDcimRacksCreateParamsWithTimeout(timeout time.Duration) *DcimRacksCreateParams

+ func (o *DcimRacksCreateParams) SetContext(ctx context.Context)

+ func (o *DcimRacksCreateParams) SetData(data *models.Rack)

+ func (o *DcimRacksCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksCreateParams) WithContext(ctx context.Context) *DcimRacksCreateParams

+ func (o *DcimRacksCreateParams) WithData(data *models.Rack) *DcimRacksCreateParams

+ func (o *DcimRacksCreateParams) WithHTTPClient(client *http.Client) *DcimRacksCreateParams

+ func (o *DcimRacksCreateParams) WithTimeout(timeout time.Duration) *DcimRacksCreateParams

+ func (o *DcimRacksCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksCreateReader struct

+ func (o *DcimRacksCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksDeleteNoContent struct

+ func NewDcimRacksDeleteNoContent() *DcimRacksDeleteNoContent

+ func (o *DcimRacksDeleteNoContent) Error() string

+ type DcimRacksDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRacksDeleteParams() *DcimRacksDeleteParams

+ func NewDcimRacksDeleteParamsWithContext(ctx context.Context) *DcimRacksDeleteParams

+ func NewDcimRacksDeleteParamsWithHTTPClient(client *http.Client) *DcimRacksDeleteParams

+ func NewDcimRacksDeleteParamsWithTimeout(timeout time.Duration) *DcimRacksDeleteParams

+ func (o *DcimRacksDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimRacksDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksDeleteParams) SetID(id int64)

+ func (o *DcimRacksDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksDeleteParams) WithContext(ctx context.Context) *DcimRacksDeleteParams

+ func (o *DcimRacksDeleteParams) WithHTTPClient(client *http.Client) *DcimRacksDeleteParams

+ func (o *DcimRacksDeleteParams) WithID(id int64) *DcimRacksDeleteParams

+ func (o *DcimRacksDeleteParams) WithTimeout(timeout time.Duration) *DcimRacksDeleteParams

+ func (o *DcimRacksDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksDeleteReader struct

+ func (o *DcimRacksDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksListOK struct

+ Payload *DcimRacksListOKBody

+ func NewDcimRacksListOK() *DcimRacksListOK

+ func (o *DcimRacksListOK) Error() string

+ type DcimRacksListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Rack

+ func (o *DcimRacksListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimRacksListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimRacksListOKBody) Validate(formats strfmt.Registry) error

+ type DcimRacksListParams struct

+ Context context.Context

+ DescUnits *string

+ FacilityID *string

+ Group *string

+ GroupID *string

+ HTTPClient *http.Client

+ IDIn *string

+ Limit *int64

+ Name *string

+ Offset *int64

+ Q *string

+ Role *string

+ RoleID *string

+ Serial *string

+ Site *string

+ SiteID *string

+ Tag *string

+ Tenant *string

+ TenantID *string

+ Type *string

+ UHeight *float64

+ Width *string

+ func NewDcimRacksListParams() *DcimRacksListParams

+ func NewDcimRacksListParamsWithContext(ctx context.Context) *DcimRacksListParams

+ func NewDcimRacksListParamsWithHTTPClient(client *http.Client) *DcimRacksListParams

+ func NewDcimRacksListParamsWithTimeout(timeout time.Duration) *DcimRacksListParams

+ func (o *DcimRacksListParams) SetContext(ctx context.Context)

+ func (o *DcimRacksListParams) SetDescUnits(descUnits *string)

+ func (o *DcimRacksListParams) SetFacilityID(facilityID *string)

+ func (o *DcimRacksListParams) SetGroup(group *string)

+ func (o *DcimRacksListParams) SetGroupID(groupID *string)

+ func (o *DcimRacksListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksListParams) SetIDIn(iDIn *string)

+ func (o *DcimRacksListParams) SetLimit(limit *int64)

+ func (o *DcimRacksListParams) SetName(name *string)

+ func (o *DcimRacksListParams) SetOffset(offset *int64)

+ func (o *DcimRacksListParams) SetQ(q *string)

+ func (o *DcimRacksListParams) SetRole(role *string)

+ func (o *DcimRacksListParams) SetRoleID(roleID *string)

+ func (o *DcimRacksListParams) SetSerial(serial *string)

+ func (o *DcimRacksListParams) SetSite(site *string)

+ func (o *DcimRacksListParams) SetSiteID(siteID *string)

+ func (o *DcimRacksListParams) SetTag(tag *string)

+ func (o *DcimRacksListParams) SetTenant(tenant *string)

+ func (o *DcimRacksListParams) SetTenantID(tenantID *string)

+ func (o *DcimRacksListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksListParams) SetType(typeVar *string)

+ func (o *DcimRacksListParams) SetUHeight(uHeight *float64)

+ func (o *DcimRacksListParams) SetWidth(width *string)

+ func (o *DcimRacksListParams) WithContext(ctx context.Context) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithDescUnits(descUnits *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithFacilityID(facilityID *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithGroup(group *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithGroupID(groupID *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithHTTPClient(client *http.Client) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithIDIn(iDIn *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithLimit(limit *int64) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithName(name *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithOffset(offset *int64) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithQ(q *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithRole(role *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithRoleID(roleID *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithSerial(serial *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithSite(site *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithSiteID(siteID *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithTag(tag *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithTenant(tenant *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithTenantID(tenantID *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithTimeout(timeout time.Duration) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithType(typeVar *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithUHeight(uHeight *float64) *DcimRacksListParams

+ func (o *DcimRacksListParams) WithWidth(width *string) *DcimRacksListParams

+ func (o *DcimRacksListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksListReader struct

+ func (o *DcimRacksListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksPartialUpdateOK struct

+ Payload *models.Rack

+ func NewDcimRacksPartialUpdateOK() *DcimRacksPartialUpdateOK

+ func (o *DcimRacksPartialUpdateOK) Error() string

+ type DcimRacksPartialUpdateParams struct

+ Context context.Context

+ Data *models.Rack

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRacksPartialUpdateParams() *DcimRacksPartialUpdateParams

+ func NewDcimRacksPartialUpdateParamsWithContext(ctx context.Context) *DcimRacksPartialUpdateParams

+ func NewDcimRacksPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimRacksPartialUpdateParams

+ func NewDcimRacksPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRacksPartialUpdateParams) SetData(data *models.Rack)

+ func (o *DcimRacksPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksPartialUpdateParams) SetID(id int64)

+ func (o *DcimRacksPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksPartialUpdateParams) WithContext(ctx context.Context) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) WithData(data *models.Rack) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) WithID(id int64) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimRacksPartialUpdateParams

+ func (o *DcimRacksPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksPartialUpdateReader struct

+ func (o *DcimRacksPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksReadOK struct

+ Payload *models.Rack

+ func NewDcimRacksReadOK() *DcimRacksReadOK

+ func (o *DcimRacksReadOK) Error() string

+ type DcimRacksReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRacksReadParams() *DcimRacksReadParams

+ func NewDcimRacksReadParamsWithContext(ctx context.Context) *DcimRacksReadParams

+ func NewDcimRacksReadParamsWithHTTPClient(client *http.Client) *DcimRacksReadParams

+ func NewDcimRacksReadParamsWithTimeout(timeout time.Duration) *DcimRacksReadParams

+ func (o *DcimRacksReadParams) SetContext(ctx context.Context)

+ func (o *DcimRacksReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksReadParams) SetID(id int64)

+ func (o *DcimRacksReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksReadParams) WithContext(ctx context.Context) *DcimRacksReadParams

+ func (o *DcimRacksReadParams) WithHTTPClient(client *http.Client) *DcimRacksReadParams

+ func (o *DcimRacksReadParams) WithID(id int64) *DcimRacksReadParams

+ func (o *DcimRacksReadParams) WithTimeout(timeout time.Duration) *DcimRacksReadParams

+ func (o *DcimRacksReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksReadReader struct

+ func (o *DcimRacksReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksUnitsOK struct

+ Payload *models.Rack

+ func NewDcimRacksUnitsOK() *DcimRacksUnitsOK

+ func (o *DcimRacksUnitsOK) Error() string

+ type DcimRacksUnitsParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRacksUnitsParams() *DcimRacksUnitsParams

+ func NewDcimRacksUnitsParamsWithContext(ctx context.Context) *DcimRacksUnitsParams

+ func NewDcimRacksUnitsParamsWithHTTPClient(client *http.Client) *DcimRacksUnitsParams

+ func NewDcimRacksUnitsParamsWithTimeout(timeout time.Duration) *DcimRacksUnitsParams

+ func (o *DcimRacksUnitsParams) SetContext(ctx context.Context)

+ func (o *DcimRacksUnitsParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksUnitsParams) SetID(id int64)

+ func (o *DcimRacksUnitsParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksUnitsParams) WithContext(ctx context.Context) *DcimRacksUnitsParams

+ func (o *DcimRacksUnitsParams) WithHTTPClient(client *http.Client) *DcimRacksUnitsParams

+ func (o *DcimRacksUnitsParams) WithID(id int64) *DcimRacksUnitsParams

+ func (o *DcimRacksUnitsParams) WithTimeout(timeout time.Duration) *DcimRacksUnitsParams

+ func (o *DcimRacksUnitsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksUnitsReader struct

+ func (o *DcimRacksUnitsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRacksUpdateOK struct

+ Payload *models.Rack

+ func NewDcimRacksUpdateOK() *DcimRacksUpdateOK

+ func (o *DcimRacksUpdateOK) Error() string

+ type DcimRacksUpdateParams struct

+ Context context.Context

+ Data *models.Rack

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRacksUpdateParams() *DcimRacksUpdateParams

+ func NewDcimRacksUpdateParamsWithContext(ctx context.Context) *DcimRacksUpdateParams

+ func NewDcimRacksUpdateParamsWithHTTPClient(client *http.Client) *DcimRacksUpdateParams

+ func NewDcimRacksUpdateParamsWithTimeout(timeout time.Duration) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRacksUpdateParams) SetData(data *models.Rack)

+ func (o *DcimRacksUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRacksUpdateParams) SetID(id int64)

+ func (o *DcimRacksUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRacksUpdateParams) WithContext(ctx context.Context) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) WithData(data *models.Rack) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) WithHTTPClient(client *http.Client) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) WithID(id int64) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) WithTimeout(timeout time.Duration) *DcimRacksUpdateParams

+ func (o *DcimRacksUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRacksUpdateReader struct

+ func (o *DcimRacksUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsCreateCreated struct

+ Payload *models.Region

+ func NewDcimRegionsCreateCreated() *DcimRegionsCreateCreated

+ func (o *DcimRegionsCreateCreated) Error() string

+ type DcimRegionsCreateParams struct

+ Context context.Context

+ Data *models.Region

+ HTTPClient *http.Client

+ func NewDcimRegionsCreateParams() *DcimRegionsCreateParams

+ func NewDcimRegionsCreateParamsWithContext(ctx context.Context) *DcimRegionsCreateParams

+ func NewDcimRegionsCreateParamsWithHTTPClient(client *http.Client) *DcimRegionsCreateParams

+ func NewDcimRegionsCreateParamsWithTimeout(timeout time.Duration) *DcimRegionsCreateParams

+ func (o *DcimRegionsCreateParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsCreateParams) SetData(data *models.Region)

+ func (o *DcimRegionsCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsCreateParams) WithContext(ctx context.Context) *DcimRegionsCreateParams

+ func (o *DcimRegionsCreateParams) WithData(data *models.Region) *DcimRegionsCreateParams

+ func (o *DcimRegionsCreateParams) WithHTTPClient(client *http.Client) *DcimRegionsCreateParams

+ func (o *DcimRegionsCreateParams) WithTimeout(timeout time.Duration) *DcimRegionsCreateParams

+ func (o *DcimRegionsCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsCreateReader struct

+ func (o *DcimRegionsCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsDeleteNoContent struct

+ func NewDcimRegionsDeleteNoContent() *DcimRegionsDeleteNoContent

+ func (o *DcimRegionsDeleteNoContent) Error() string

+ type DcimRegionsDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRegionsDeleteParams() *DcimRegionsDeleteParams

+ func NewDcimRegionsDeleteParamsWithContext(ctx context.Context) *DcimRegionsDeleteParams

+ func NewDcimRegionsDeleteParamsWithHTTPClient(client *http.Client) *DcimRegionsDeleteParams

+ func NewDcimRegionsDeleteParamsWithTimeout(timeout time.Duration) *DcimRegionsDeleteParams

+ func (o *DcimRegionsDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsDeleteParams) SetID(id int64)

+ func (o *DcimRegionsDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsDeleteParams) WithContext(ctx context.Context) *DcimRegionsDeleteParams

+ func (o *DcimRegionsDeleteParams) WithHTTPClient(client *http.Client) *DcimRegionsDeleteParams

+ func (o *DcimRegionsDeleteParams) WithID(id int64) *DcimRegionsDeleteParams

+ func (o *DcimRegionsDeleteParams) WithTimeout(timeout time.Duration) *DcimRegionsDeleteParams

+ func (o *DcimRegionsDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsDeleteReader struct

+ func (o *DcimRegionsDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsListOK struct

+ Payload *DcimRegionsListOKBody

+ func NewDcimRegionsListOK() *DcimRegionsListOK

+ func (o *DcimRegionsListOK) Error() string

+ type DcimRegionsListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Region

+ func (o *DcimRegionsListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimRegionsListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimRegionsListOKBody) Validate(formats strfmt.Registry) error

+ type DcimRegionsListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Name *string

+ Offset *int64

+ Parent *string

+ ParentID *string

+ Q *string

+ Slug *string

+ func NewDcimRegionsListParams() *DcimRegionsListParams

+ func NewDcimRegionsListParamsWithContext(ctx context.Context) *DcimRegionsListParams

+ func NewDcimRegionsListParamsWithHTTPClient(client *http.Client) *DcimRegionsListParams

+ func NewDcimRegionsListParamsWithTimeout(timeout time.Duration) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsListParams) SetLimit(limit *int64)

+ func (o *DcimRegionsListParams) SetName(name *string)

+ func (o *DcimRegionsListParams) SetOffset(offset *int64)

+ func (o *DcimRegionsListParams) SetParent(parent *string)

+ func (o *DcimRegionsListParams) SetParentID(parentID *string)

+ func (o *DcimRegionsListParams) SetQ(q *string)

+ func (o *DcimRegionsListParams) SetSlug(slug *string)

+ func (o *DcimRegionsListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsListParams) WithContext(ctx context.Context) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithHTTPClient(client *http.Client) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithLimit(limit *int64) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithName(name *string) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithOffset(offset *int64) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithParent(parent *string) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithParentID(parentID *string) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithQ(q *string) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithSlug(slug *string) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WithTimeout(timeout time.Duration) *DcimRegionsListParams

+ func (o *DcimRegionsListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsListReader struct

+ func (o *DcimRegionsListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsPartialUpdateOK struct

+ Payload *models.Region

+ func NewDcimRegionsPartialUpdateOK() *DcimRegionsPartialUpdateOK

+ func (o *DcimRegionsPartialUpdateOK) Error() string

+ type DcimRegionsPartialUpdateParams struct

+ Context context.Context

+ Data *models.Region

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRegionsPartialUpdateParams() *DcimRegionsPartialUpdateParams

+ func NewDcimRegionsPartialUpdateParamsWithContext(ctx context.Context) *DcimRegionsPartialUpdateParams

+ func NewDcimRegionsPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimRegionsPartialUpdateParams

+ func NewDcimRegionsPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsPartialUpdateParams) SetData(data *models.Region)

+ func (o *DcimRegionsPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsPartialUpdateParams) SetID(id int64)

+ func (o *DcimRegionsPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsPartialUpdateParams) WithContext(ctx context.Context) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) WithData(data *models.Region) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) WithID(id int64) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimRegionsPartialUpdateParams

+ func (o *DcimRegionsPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsPartialUpdateReader struct

+ func (o *DcimRegionsPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsReadOK struct

+ Payload *models.Region

+ func NewDcimRegionsReadOK() *DcimRegionsReadOK

+ func (o *DcimRegionsReadOK) Error() string

+ type DcimRegionsReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRegionsReadParams() *DcimRegionsReadParams

+ func NewDcimRegionsReadParamsWithContext(ctx context.Context) *DcimRegionsReadParams

+ func NewDcimRegionsReadParamsWithHTTPClient(client *http.Client) *DcimRegionsReadParams

+ func NewDcimRegionsReadParamsWithTimeout(timeout time.Duration) *DcimRegionsReadParams

+ func (o *DcimRegionsReadParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsReadParams) SetID(id int64)

+ func (o *DcimRegionsReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsReadParams) WithContext(ctx context.Context) *DcimRegionsReadParams

+ func (o *DcimRegionsReadParams) WithHTTPClient(client *http.Client) *DcimRegionsReadParams

+ func (o *DcimRegionsReadParams) WithID(id int64) *DcimRegionsReadParams

+ func (o *DcimRegionsReadParams) WithTimeout(timeout time.Duration) *DcimRegionsReadParams

+ func (o *DcimRegionsReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsReadReader struct

+ func (o *DcimRegionsReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimRegionsUpdateOK struct

+ Payload *models.Region

+ func NewDcimRegionsUpdateOK() *DcimRegionsUpdateOK

+ func (o *DcimRegionsUpdateOK) Error() string

+ type DcimRegionsUpdateParams struct

+ Context context.Context

+ Data *models.Region

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimRegionsUpdateParams() *DcimRegionsUpdateParams

+ func NewDcimRegionsUpdateParamsWithContext(ctx context.Context) *DcimRegionsUpdateParams

+ func NewDcimRegionsUpdateParamsWithHTTPClient(client *http.Client) *DcimRegionsUpdateParams

+ func NewDcimRegionsUpdateParamsWithTimeout(timeout time.Duration) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimRegionsUpdateParams) SetData(data *models.Region)

+ func (o *DcimRegionsUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimRegionsUpdateParams) SetID(id int64)

+ func (o *DcimRegionsUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimRegionsUpdateParams) WithContext(ctx context.Context) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) WithData(data *models.Region) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) WithHTTPClient(client *http.Client) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) WithID(id int64) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) WithTimeout(timeout time.Duration) *DcimRegionsUpdateParams

+ func (o *DcimRegionsUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimRegionsUpdateReader struct

+ func (o *DcimRegionsUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesCreateCreated struct

+ Payload *models.Site

+ func NewDcimSitesCreateCreated() *DcimSitesCreateCreated

+ func (o *DcimSitesCreateCreated) Error() string

+ type DcimSitesCreateParams struct

+ Context context.Context

+ Data *models.Site

+ HTTPClient *http.Client

+ func NewDcimSitesCreateParams() *DcimSitesCreateParams

+ func NewDcimSitesCreateParamsWithContext(ctx context.Context) *DcimSitesCreateParams

+ func NewDcimSitesCreateParamsWithHTTPClient(client *http.Client) *DcimSitesCreateParams

+ func NewDcimSitesCreateParamsWithTimeout(timeout time.Duration) *DcimSitesCreateParams

+ func (o *DcimSitesCreateParams) SetContext(ctx context.Context)

+ func (o *DcimSitesCreateParams) SetData(data *models.Site)

+ func (o *DcimSitesCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesCreateParams) WithContext(ctx context.Context) *DcimSitesCreateParams

+ func (o *DcimSitesCreateParams) WithData(data *models.Site) *DcimSitesCreateParams

+ func (o *DcimSitesCreateParams) WithHTTPClient(client *http.Client) *DcimSitesCreateParams

+ func (o *DcimSitesCreateParams) WithTimeout(timeout time.Duration) *DcimSitesCreateParams

+ func (o *DcimSitesCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesCreateReader struct

+ func (o *DcimSitesCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesDeleteNoContent struct

+ func NewDcimSitesDeleteNoContent() *DcimSitesDeleteNoContent

+ func (o *DcimSitesDeleteNoContent) Error() string

+ type DcimSitesDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimSitesDeleteParams() *DcimSitesDeleteParams

+ func NewDcimSitesDeleteParamsWithContext(ctx context.Context) *DcimSitesDeleteParams

+ func NewDcimSitesDeleteParamsWithHTTPClient(client *http.Client) *DcimSitesDeleteParams

+ func NewDcimSitesDeleteParamsWithTimeout(timeout time.Duration) *DcimSitesDeleteParams

+ func (o *DcimSitesDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimSitesDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesDeleteParams) SetID(id int64)

+ func (o *DcimSitesDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesDeleteParams) WithContext(ctx context.Context) *DcimSitesDeleteParams

+ func (o *DcimSitesDeleteParams) WithHTTPClient(client *http.Client) *DcimSitesDeleteParams

+ func (o *DcimSitesDeleteParams) WithID(id int64) *DcimSitesDeleteParams

+ func (o *DcimSitesDeleteParams) WithTimeout(timeout time.Duration) *DcimSitesDeleteParams

+ func (o *DcimSitesDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesDeleteReader struct

+ func (o *DcimSitesDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesGraphsOK struct

+ Payload *models.Site

+ func NewDcimSitesGraphsOK() *DcimSitesGraphsOK

+ func (o *DcimSitesGraphsOK) Error() string

+ type DcimSitesGraphsParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimSitesGraphsParams() *DcimSitesGraphsParams

+ func NewDcimSitesGraphsParamsWithContext(ctx context.Context) *DcimSitesGraphsParams

+ func NewDcimSitesGraphsParamsWithHTTPClient(client *http.Client) *DcimSitesGraphsParams

+ func NewDcimSitesGraphsParamsWithTimeout(timeout time.Duration) *DcimSitesGraphsParams

+ func (o *DcimSitesGraphsParams) SetContext(ctx context.Context)

+ func (o *DcimSitesGraphsParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesGraphsParams) SetID(id int64)

+ func (o *DcimSitesGraphsParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesGraphsParams) WithContext(ctx context.Context) *DcimSitesGraphsParams

+ func (o *DcimSitesGraphsParams) WithHTTPClient(client *http.Client) *DcimSitesGraphsParams

+ func (o *DcimSitesGraphsParams) WithID(id int64) *DcimSitesGraphsParams

+ func (o *DcimSitesGraphsParams) WithTimeout(timeout time.Duration) *DcimSitesGraphsParams

+ func (o *DcimSitesGraphsParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesGraphsReader struct

+ func (o *DcimSitesGraphsReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesListOK struct

+ Payload *DcimSitesListOKBody

+ func NewDcimSitesListOK() *DcimSitesListOK

+ func (o *DcimSitesListOK) Error() string

+ type DcimSitesListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.Site

+ func (o *DcimSitesListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimSitesListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimSitesListOKBody) Validate(formats strfmt.Registry) error

+ type DcimSitesListParams struct

+ Asn *float64

+ ContactEmail *string

+ ContactName *string

+ ContactPhone *string

+ Context context.Context

+ Facility *string

+ HTTPClient *http.Client

+ IDIn *string

+ Limit *int64

+ Name *string

+ Offset *int64

+ Q *string

+ Region *string

+ RegionID *string

+ Slug *string

+ Status *string

+ Tag *string

+ Tenant *string

+ TenantID *string

+ func NewDcimSitesListParams() *DcimSitesListParams

+ func NewDcimSitesListParamsWithContext(ctx context.Context) *DcimSitesListParams

+ func NewDcimSitesListParamsWithHTTPClient(client *http.Client) *DcimSitesListParams

+ func NewDcimSitesListParamsWithTimeout(timeout time.Duration) *DcimSitesListParams

+ func (o *DcimSitesListParams) SetAsn(asn *float64)

+ func (o *DcimSitesListParams) SetContactEmail(contactEmail *string)

+ func (o *DcimSitesListParams) SetContactName(contactName *string)

+ func (o *DcimSitesListParams) SetContactPhone(contactPhone *string)

+ func (o *DcimSitesListParams) SetContext(ctx context.Context)

+ func (o *DcimSitesListParams) SetFacility(facility *string)

+ func (o *DcimSitesListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesListParams) SetIDIn(iDIn *string)

+ func (o *DcimSitesListParams) SetLimit(limit *int64)

+ func (o *DcimSitesListParams) SetName(name *string)

+ func (o *DcimSitesListParams) SetOffset(offset *int64)

+ func (o *DcimSitesListParams) SetQ(q *string)

+ func (o *DcimSitesListParams) SetRegion(region *string)

+ func (o *DcimSitesListParams) SetRegionID(regionID *string)

+ func (o *DcimSitesListParams) SetSlug(slug *string)

+ func (o *DcimSitesListParams) SetStatus(status *string)

+ func (o *DcimSitesListParams) SetTag(tag *string)

+ func (o *DcimSitesListParams) SetTenant(tenant *string)

+ func (o *DcimSitesListParams) SetTenantID(tenantID *string)

+ func (o *DcimSitesListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesListParams) WithAsn(asn *float64) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithContactEmail(contactEmail *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithContactName(contactName *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithContactPhone(contactPhone *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithContext(ctx context.Context) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithFacility(facility *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithHTTPClient(client *http.Client) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithIDIn(iDIn *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithLimit(limit *int64) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithName(name *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithOffset(offset *int64) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithQ(q *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithRegion(region *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithRegionID(regionID *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithSlug(slug *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithStatus(status *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithTag(tag *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithTenant(tenant *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithTenantID(tenantID *string) *DcimSitesListParams

+ func (o *DcimSitesListParams) WithTimeout(timeout time.Duration) *DcimSitesListParams

+ func (o *DcimSitesListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesListReader struct

+ func (o *DcimSitesListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesPartialUpdateOK struct

+ Payload *models.Site

+ func NewDcimSitesPartialUpdateOK() *DcimSitesPartialUpdateOK

+ func (o *DcimSitesPartialUpdateOK) Error() string

+ type DcimSitesPartialUpdateParams struct

+ Context context.Context

+ Data *models.Site

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimSitesPartialUpdateParams() *DcimSitesPartialUpdateParams

+ func NewDcimSitesPartialUpdateParamsWithContext(ctx context.Context) *DcimSitesPartialUpdateParams

+ func NewDcimSitesPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimSitesPartialUpdateParams

+ func NewDcimSitesPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimSitesPartialUpdateParams) SetData(data *models.Site)

+ func (o *DcimSitesPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesPartialUpdateParams) SetID(id int64)

+ func (o *DcimSitesPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesPartialUpdateParams) WithContext(ctx context.Context) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) WithData(data *models.Site) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) WithID(id int64) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimSitesPartialUpdateParams

+ func (o *DcimSitesPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesPartialUpdateReader struct

+ func (o *DcimSitesPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesReadOK struct

+ Payload *models.Site

+ func NewDcimSitesReadOK() *DcimSitesReadOK

+ func (o *DcimSitesReadOK) Error() string

+ type DcimSitesReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimSitesReadParams() *DcimSitesReadParams

+ func NewDcimSitesReadParamsWithContext(ctx context.Context) *DcimSitesReadParams

+ func NewDcimSitesReadParamsWithHTTPClient(client *http.Client) *DcimSitesReadParams

+ func NewDcimSitesReadParamsWithTimeout(timeout time.Duration) *DcimSitesReadParams

+ func (o *DcimSitesReadParams) SetContext(ctx context.Context)

+ func (o *DcimSitesReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesReadParams) SetID(id int64)

+ func (o *DcimSitesReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesReadParams) WithContext(ctx context.Context) *DcimSitesReadParams

+ func (o *DcimSitesReadParams) WithHTTPClient(client *http.Client) *DcimSitesReadParams

+ func (o *DcimSitesReadParams) WithID(id int64) *DcimSitesReadParams

+ func (o *DcimSitesReadParams) WithTimeout(timeout time.Duration) *DcimSitesReadParams

+ func (o *DcimSitesReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesReadReader struct

+ func (o *DcimSitesReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimSitesUpdateOK struct

+ Payload *models.Site

+ func NewDcimSitesUpdateOK() *DcimSitesUpdateOK

+ func (o *DcimSitesUpdateOK) Error() string

+ type DcimSitesUpdateParams struct

+ Context context.Context

+ Data *models.Site

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimSitesUpdateParams() *DcimSitesUpdateParams

+ func NewDcimSitesUpdateParamsWithContext(ctx context.Context) *DcimSitesUpdateParams

+ func NewDcimSitesUpdateParamsWithHTTPClient(client *http.Client) *DcimSitesUpdateParams

+ func NewDcimSitesUpdateParamsWithTimeout(timeout time.Duration) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimSitesUpdateParams) SetData(data *models.Site)

+ func (o *DcimSitesUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimSitesUpdateParams) SetID(id int64)

+ func (o *DcimSitesUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimSitesUpdateParams) WithContext(ctx context.Context) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) WithData(data *models.Site) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) WithHTTPClient(client *http.Client) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) WithID(id int64) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) WithTimeout(timeout time.Duration) *DcimSitesUpdateParams

+ func (o *DcimSitesUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimSitesUpdateReader struct

+ func (o *DcimSitesUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisCreateCreated struct

+ Payload *models.VirtualChassis

+ func NewDcimVirtualChassisCreateCreated() *DcimVirtualChassisCreateCreated

+ func (o *DcimVirtualChassisCreateCreated) Error() string

+ type DcimVirtualChassisCreateParams struct

+ Context context.Context

+ Data *models.VirtualChassis

+ HTTPClient *http.Client

+ func NewDcimVirtualChassisCreateParams() *DcimVirtualChassisCreateParams

+ func NewDcimVirtualChassisCreateParamsWithContext(ctx context.Context) *DcimVirtualChassisCreateParams

+ func NewDcimVirtualChassisCreateParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisCreateParams

+ func NewDcimVirtualChassisCreateParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisCreateParams

+ func (o *DcimVirtualChassisCreateParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisCreateParams) SetData(data *models.VirtualChassis)

+ func (o *DcimVirtualChassisCreateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisCreateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisCreateParams) WithContext(ctx context.Context) *DcimVirtualChassisCreateParams

+ func (o *DcimVirtualChassisCreateParams) WithData(data *models.VirtualChassis) *DcimVirtualChassisCreateParams

+ func (o *DcimVirtualChassisCreateParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisCreateParams

+ func (o *DcimVirtualChassisCreateParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisCreateParams

+ func (o *DcimVirtualChassisCreateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisCreateReader struct

+ func (o *DcimVirtualChassisCreateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisDeleteNoContent struct

+ func NewDcimVirtualChassisDeleteNoContent() *DcimVirtualChassisDeleteNoContent

+ func (o *DcimVirtualChassisDeleteNoContent) Error() string

+ type DcimVirtualChassisDeleteParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimVirtualChassisDeleteParams() *DcimVirtualChassisDeleteParams

+ func NewDcimVirtualChassisDeleteParamsWithContext(ctx context.Context) *DcimVirtualChassisDeleteParams

+ func NewDcimVirtualChassisDeleteParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisDeleteParams

+ func NewDcimVirtualChassisDeleteParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisDeleteParams

+ func (o *DcimVirtualChassisDeleteParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisDeleteParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisDeleteParams) SetID(id int64)

+ func (o *DcimVirtualChassisDeleteParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisDeleteParams) WithContext(ctx context.Context) *DcimVirtualChassisDeleteParams

+ func (o *DcimVirtualChassisDeleteParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisDeleteParams

+ func (o *DcimVirtualChassisDeleteParams) WithID(id int64) *DcimVirtualChassisDeleteParams

+ func (o *DcimVirtualChassisDeleteParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisDeleteParams

+ func (o *DcimVirtualChassisDeleteParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisDeleteReader struct

+ func (o *DcimVirtualChassisDeleteReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisListOK struct

+ Payload *DcimVirtualChassisListOKBody

+ func NewDcimVirtualChassisListOK() *DcimVirtualChassisListOK

+ func (o *DcimVirtualChassisListOK) Error() string

+ type DcimVirtualChassisListOKBody struct

+ Count *int64

+ Next *strfmt.URI

+ Previous *strfmt.URI

+ Results []*models.VirtualChassis

+ func (o *DcimVirtualChassisListOKBody) MarshalBinary() ([]byte, error)

+ func (o *DcimVirtualChassisListOKBody) UnmarshalBinary(b []byte) error

+ func (o *DcimVirtualChassisListOKBody) Validate(formats strfmt.Registry) error

+ type DcimVirtualChassisListParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ Limit *int64

+ Offset *int64

+ func NewDcimVirtualChassisListParams() *DcimVirtualChassisListParams

+ func NewDcimVirtualChassisListParamsWithContext(ctx context.Context) *DcimVirtualChassisListParams

+ func NewDcimVirtualChassisListParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisListParams

+ func NewDcimVirtualChassisListParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisListParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisListParams) SetLimit(limit *int64)

+ func (o *DcimVirtualChassisListParams) SetOffset(offset *int64)

+ func (o *DcimVirtualChassisListParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisListParams) WithContext(ctx context.Context) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) WithLimit(limit *int64) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) WithOffset(offset *int64) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisListParams

+ func (o *DcimVirtualChassisListParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisListReader struct

+ func (o *DcimVirtualChassisListReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisPartialUpdateOK struct

+ Payload *models.VirtualChassis

+ func NewDcimVirtualChassisPartialUpdateOK() *DcimVirtualChassisPartialUpdateOK

+ func (o *DcimVirtualChassisPartialUpdateOK) Error() string

+ type DcimVirtualChassisPartialUpdateParams struct

+ Context context.Context

+ Data *models.VirtualChassis

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimVirtualChassisPartialUpdateParams() *DcimVirtualChassisPartialUpdateParams

+ func NewDcimVirtualChassisPartialUpdateParamsWithContext(ctx context.Context) *DcimVirtualChassisPartialUpdateParams

+ func NewDcimVirtualChassisPartialUpdateParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisPartialUpdateParams

+ func NewDcimVirtualChassisPartialUpdateParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisPartialUpdateParams) SetData(data *models.VirtualChassis)

+ func (o *DcimVirtualChassisPartialUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisPartialUpdateParams) SetID(id int64)

+ func (o *DcimVirtualChassisPartialUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisPartialUpdateParams) WithContext(ctx context.Context) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) WithData(data *models.VirtualChassis) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) WithID(id int64) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisPartialUpdateParams

+ func (o *DcimVirtualChassisPartialUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisPartialUpdateReader struct

+ func (o *DcimVirtualChassisPartialUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisReadOK struct

+ Payload *models.VirtualChassis

+ func NewDcimVirtualChassisReadOK() *DcimVirtualChassisReadOK

+ func (o *DcimVirtualChassisReadOK) Error() string

+ type DcimVirtualChassisReadParams struct

+ Context context.Context

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimVirtualChassisReadParams() *DcimVirtualChassisReadParams

+ func NewDcimVirtualChassisReadParamsWithContext(ctx context.Context) *DcimVirtualChassisReadParams

+ func NewDcimVirtualChassisReadParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisReadParams

+ func NewDcimVirtualChassisReadParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisReadParams

+ func (o *DcimVirtualChassisReadParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisReadParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisReadParams) SetID(id int64)

+ func (o *DcimVirtualChassisReadParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisReadParams) WithContext(ctx context.Context) *DcimVirtualChassisReadParams

+ func (o *DcimVirtualChassisReadParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisReadParams

+ func (o *DcimVirtualChassisReadParams) WithID(id int64) *DcimVirtualChassisReadParams

+ func (o *DcimVirtualChassisReadParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisReadParams

+ func (o *DcimVirtualChassisReadParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisReadReader struct

+ func (o *DcimVirtualChassisReadReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)

+ type DcimVirtualChassisUpdateOK struct

+ Payload *models.VirtualChassis

+ func NewDcimVirtualChassisUpdateOK() *DcimVirtualChassisUpdateOK

+ func (o *DcimVirtualChassisUpdateOK) Error() string

+ type DcimVirtualChassisUpdateParams struct

+ Context context.Context

+ Data *models.VirtualChassis

+ HTTPClient *http.Client

+ ID int64

+ func NewDcimVirtualChassisUpdateParams() *DcimVirtualChassisUpdateParams

+ func NewDcimVirtualChassisUpdateParamsWithContext(ctx context.Context) *DcimVirtualChassisUpdateParams

+ func NewDcimVirtualChassisUpdateParamsWithHTTPClient(client *http.Client) *DcimVirtualChassisUpdateParams

+ func NewDcimVirtualChassisUpdateParamsWithTimeout(timeout time.Duration) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) SetContext(ctx context.Context)

+ func (o *DcimVirtualChassisUpdateParams) SetData(data *models.VirtualChassis)

+ func (o *DcimVirtualChassisUpdateParams) SetHTTPClient(client *http.Client)

+ func (o *DcimVirtualChassisUpdateParams) SetID(id int64)

+ func (o *DcimVirtualChassisUpdateParams) SetTimeout(timeout time.Duration)

+ func (o *DcimVirtualChassisUpdateParams) WithContext(ctx context.Context) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) WithData(data *models.VirtualChassis) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) WithHTTPClient(client *http.Client) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) WithID(id int64) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) WithTimeout(timeout time.Duration) *DcimVirtualChassisUpdateParams

+ func (o *DcimVirtualChassisUpdateParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error

+ type DcimVirtualChassisUpdateReader struct

+ func (o *DcimVirtualChassisUpdateReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error)