models

package
v0.0.0-...-1915fbc Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Apr 25, 2020 License: Apache-2.0 Imports: 6 Imported by: 0

Documentation

Index

Constants

View Source 
const (

	// CableTypeCat3 captures enum value "cat3"
	CableTypeCat3 string = "cat3"

	// CableTypeCat5 captures enum value "cat5"
	CableTypeCat5 string = "cat5"

	// CableTypeCat5e captures enum value "cat5e"
	CableTypeCat5e string = "cat5e"

	// CableTypeCat6 captures enum value "cat6"
	CableTypeCat6 string = "cat6"

	// CableTypeCat6a captures enum value "cat6a"
	CableTypeCat6a string = "cat6a"

	// CableTypeCat7 captures enum value "cat7"
	CableTypeCat7 string = "cat7"

	// CableTypeDacActive captures enum value "dac-active"
	CableTypeDacActive string = "dac-active"

	// CableTypeDacPassive captures enum value "dac-passive"
	CableTypeDacPassive string = "dac-passive"

	// CableTypeCoaxial captures enum value "coaxial"
	CableTypeCoaxial string = "coaxial"

	// CableTypeMmf captures enum value "mmf"
	CableTypeMmf string = "mmf"

	// CableTypeMmfOm1 captures enum value "mmf-om1"
	CableTypeMmfOm1 string = "mmf-om1"

	// CableTypeMmfOm2 captures enum value "mmf-om2"
	CableTypeMmfOm2 string = "mmf-om2"

	// CableTypeMmfOm3 captures enum value "mmf-om3"
	CableTypeMmfOm3 string = "mmf-om3"

	// CableTypeMmfOm4 captures enum value "mmf-om4"
	CableTypeMmfOm4 string = "mmf-om4"

	// CableTypeSmf captures enum value "smf"
	CableTypeSmf string = "smf"

	// CableTypeSmfOs1 captures enum value "smf-os1"
	CableTypeSmfOs1 string = "smf-os1"

	// CableTypeSmfOs2 captures enum value "smf-os2"
	CableTypeSmfOs2 string = "smf-os2"

	// CableTypeAoc captures enum value "aoc"
	CableTypeAoc string = "aoc"

	// CableTypePower captures enum value "power"
	CableTypePower string = "power"
)
View Source 
const (

	// CircuitTerminationTermSideA captures enum value "A"
	CircuitTerminationTermSideA string = "A"

	// CircuitTerminationTermSideZ captures enum value "Z"
	CircuitTerminationTermSideZ string = "Z"
)
View Source 
const (

	// GraphTemplateLanguageDjango captures enum value "django"
	GraphTemplateLanguageDjango string = "django"

	// GraphTemplateLanguageJinja2 captures enum value "jinja2"
	GraphTemplateLanguageJinja2 string = "jinja2"
)
View Source 
const (

	// WritableIPAddressStatusActive captures enum value "active"
	WritableAvailableIPAddressStatusActive string = "active"

	// WritableIPAddressStatusReserved captures enum value "reserved"
	WritableAvailableIPAddressStatusReserved string = "reserved"

	// WritableIPAddressStatusDeprecated captures enum value "deprecated"
	WritableAvailableIPAddressStatusDeprecated string = "deprecated"

	// WritableIPAddressStatusDhcp captures enum value "dhcp"
	WritableAvailableIPAddressStatusDhcp string = "dhcp"
)
View Source 
const (

	// WritableCableLengthUnitM captures enum value "m"
	WritableCableLengthUnitM string = "m"

	// WritableCableLengthUnitCm captures enum value "cm"
	WritableCableLengthUnitCm string = "cm"

	// WritableCableLengthUnitFt captures enum value "ft"
	WritableCableLengthUnitFt string = "ft"

	// WritableCableLengthUnitIn captures enum value "in"
	WritableCableLengthUnitIn string = "in"
)
View Source 
const (

	// WritableCableStatusConnected captures enum value "connected"
	WritableCableStatusConnected string = "connected"

	// WritableCableStatusPlanned captures enum value "planned"
	WritableCableStatusPlanned string = "planned"

	// WritableCableStatusDecommissioning captures enum value "decommissioning"
	WritableCableStatusDecommissioning string = "decommissioning"
)
View Source 
const (

	// WritableCableTypeCat3 captures enum value "cat3"
	WritableCableTypeCat3 string = "cat3"

	// WritableCableTypeCat5 captures enum value "cat5"
	WritableCableTypeCat5 string = "cat5"

	// WritableCableTypeCat5e captures enum value "cat5e"
	WritableCableTypeCat5e string = "cat5e"

	// WritableCableTypeCat6 captures enum value "cat6"
	WritableCableTypeCat6 string = "cat6"

	// WritableCableTypeCat6a captures enum value "cat6a"
	WritableCableTypeCat6a string = "cat6a"

	// WritableCableTypeCat7 captures enum value "cat7"
	WritableCableTypeCat7 string = "cat7"

	// WritableCableTypeDacActive captures enum value "dac-active"
	WritableCableTypeDacActive string = "dac-active"

	// WritableCableTypeDacPassive captures enum value "dac-passive"
	WritableCableTypeDacPassive string = "dac-passive"

	// WritableCableTypeCoaxial captures enum value "coaxial"
	WritableCableTypeCoaxial string = "coaxial"

	// WritableCableTypeMmf captures enum value "mmf"
	WritableCableTypeMmf string = "mmf"

	// WritableCableTypeMmfOm1 captures enum value "mmf-om1"
	WritableCableTypeMmfOm1 string = "mmf-om1"

	// WritableCableTypeMmfOm2 captures enum value "mmf-om2"
	WritableCableTypeMmfOm2 string = "mmf-om2"

	// WritableCableTypeMmfOm3 captures enum value "mmf-om3"
	WritableCableTypeMmfOm3 string = "mmf-om3"

	// WritableCableTypeMmfOm4 captures enum value "mmf-om4"
	WritableCableTypeMmfOm4 string = "mmf-om4"

	// WritableCableTypeSmf captures enum value "smf"
	WritableCableTypeSmf string = "smf"

	// WritableCableTypeSmfOs1 captures enum value "smf-os1"
	WritableCableTypeSmfOs1 string = "smf-os1"

	// WritableCableTypeSmfOs2 captures enum value "smf-os2"
	WritableCableTypeSmfOs2 string = "smf-os2"

	// WritableCableTypeAoc captures enum value "aoc"
	WritableCableTypeAoc string = "aoc"

	// WritableCableTypePower captures enum value "power"
	WritableCableTypePower string = "power"
)
View Source 
const (

	// WritableCircuitStatusPlanned captures enum value "planned"
	WritableCircuitStatusPlanned string = "planned"

	// WritableCircuitStatusProvisioning captures enum value "provisioning"
	WritableCircuitStatusProvisioning string = "provisioning"

	// WritableCircuitStatusActive captures enum value "active"
	WritableCircuitStatusActive string = "active"

	// WritableCircuitStatusOffline captures enum value "offline"
	WritableCircuitStatusOffline string = "offline"

	// WritableCircuitStatusDeprovisioning captures enum value "deprovisioning"
	WritableCircuitStatusDeprovisioning string = "deprovisioning"

	// WritableCircuitStatusDecommissioned captures enum value "decommissioned"
	WritableCircuitStatusDecommissioned string = "decommissioned"
)
View Source 
const (

	// WritableCircuitTerminationTermSideA captures enum value "A"
	WritableCircuitTerminationTermSideA string = "A"

	// WritableCircuitTerminationTermSideZ captures enum value "Z"
	WritableCircuitTerminationTermSideZ string = "Z"
)
View Source 
const (

	// WritableConsolePortTypeDe9 captures enum value "de-9"
	WritableConsolePortTypeDe9 string = "de-9"

	// WritableConsolePortTypeDb25 captures enum value "db-25"
	WritableConsolePortTypeDb25 string = "db-25"

	// WritableConsolePortTypeRj11 captures enum value "rj-11"
	WritableConsolePortTypeRj11 string = "rj-11"

	// WritableConsolePortTypeRj12 captures enum value "rj-12"
	WritableConsolePortTypeRj12 string = "rj-12"

	// WritableConsolePortTypeRj45 captures enum value "rj-45"
	WritableConsolePortTypeRj45 string = "rj-45"

	// WritableConsolePortTypeUsba captures enum value "usb-a"
	WritableConsolePortTypeUsba string = "usb-a"

	// WritableConsolePortTypeUsbb captures enum value "usb-b"
	WritableConsolePortTypeUsbb string = "usb-b"

	// WritableConsolePortTypeUsbc captures enum value "usb-c"
	WritableConsolePortTypeUsbc string = "usb-c"

	// WritableConsolePortTypeUsbMinia captures enum value "usb-mini-a"
	WritableConsolePortTypeUsbMinia string = "usb-mini-a"

	// WritableConsolePortTypeUsbMinib captures enum value "usb-mini-b"
	WritableConsolePortTypeUsbMinib string = "usb-mini-b"

	// WritableConsolePortTypeUsbMicroa captures enum value "usb-micro-a"
	WritableConsolePortTypeUsbMicroa string = "usb-micro-a"

	// WritableConsolePortTypeUsbMicrob captures enum value "usb-micro-b"
	WritableConsolePortTypeUsbMicrob string = "usb-micro-b"

	// WritableConsolePortTypeOther captures enum value "other"
	WritableConsolePortTypeOther string = "other"
)
View Source 
const (

	// WritableConsolePortTemplateTypeDe9 captures enum value "de-9"
	WritableConsolePortTemplateTypeDe9 string = "de-9"

	// WritableConsolePortTemplateTypeDb25 captures enum value "db-25"
	WritableConsolePortTemplateTypeDb25 string = "db-25"

	// WritableConsolePortTemplateTypeRj11 captures enum value "rj-11"
	WritableConsolePortTemplateTypeRj11 string = "rj-11"

	// WritableConsolePortTemplateTypeRj12 captures enum value "rj-12"
	WritableConsolePortTemplateTypeRj12 string = "rj-12"

	// WritableConsolePortTemplateTypeRj45 captures enum value "rj-45"
	WritableConsolePortTemplateTypeRj45 string = "rj-45"

	// WritableConsolePortTemplateTypeUsba captures enum value "usb-a"
	WritableConsolePortTemplateTypeUsba string = "usb-a"

	// WritableConsolePortTemplateTypeUsbb captures enum value "usb-b"
	WritableConsolePortTemplateTypeUsbb string = "usb-b"

	// WritableConsolePortTemplateTypeUsbc captures enum value "usb-c"
	WritableConsolePortTemplateTypeUsbc string = "usb-c"

	// WritableConsolePortTemplateTypeUsbMinia captures enum value "usb-mini-a"
	WritableConsolePortTemplateTypeUsbMinia string = "usb-mini-a"

	// WritableConsolePortTemplateTypeUsbMinib captures enum value "usb-mini-b"
	WritableConsolePortTemplateTypeUsbMinib string = "usb-mini-b"

	// WritableConsolePortTemplateTypeUsbMicroa captures enum value "usb-micro-a"
	WritableConsolePortTemplateTypeUsbMicroa string = "usb-micro-a"

	// WritableConsolePortTemplateTypeUsbMicrob captures enum value "usb-micro-b"
	WritableConsolePortTemplateTypeUsbMicrob string = "usb-micro-b"

	// WritableConsolePortTemplateTypeOther captures enum value "other"
	WritableConsolePortTemplateTypeOther string = "other"
)
View Source 
const (

	// WritableConsoleServerPortTypeDe9 captures enum value "de-9"
	WritableConsoleServerPortTypeDe9 string = "de-9"

	// WritableConsoleServerPortTypeDb25 captures enum value "db-25"
	WritableConsoleServerPortTypeDb25 string = "db-25"

	// WritableConsoleServerPortTypeRj11 captures enum value "rj-11"
	WritableConsoleServerPortTypeRj11 string = "rj-11"

	// WritableConsoleServerPortTypeRj12 captures enum value "rj-12"
	WritableConsoleServerPortTypeRj12 string = "rj-12"

	// WritableConsoleServerPortTypeRj45 captures enum value "rj-45"
	WritableConsoleServerPortTypeRj45 string = "rj-45"

	// WritableConsoleServerPortTypeUsba captures enum value "usb-a"
	WritableConsoleServerPortTypeUsba string = "usb-a"

	// WritableConsoleServerPortTypeUsbb captures enum value "usb-b"
	WritableConsoleServerPortTypeUsbb string = "usb-b"

	// WritableConsoleServerPortTypeUsbc captures enum value "usb-c"
	WritableConsoleServerPortTypeUsbc string = "usb-c"

	// WritableConsoleServerPortTypeUsbMinia captures enum value "usb-mini-a"
	WritableConsoleServerPortTypeUsbMinia string = "usb-mini-a"

	// WritableConsoleServerPortTypeUsbMinib captures enum value "usb-mini-b"
	WritableConsoleServerPortTypeUsbMinib string = "usb-mini-b"

	// WritableConsoleServerPortTypeUsbMicroa captures enum value "usb-micro-a"
	WritableConsoleServerPortTypeUsbMicroa string = "usb-micro-a"

	// WritableConsoleServerPortTypeUsbMicrob captures enum value "usb-micro-b"
	WritableConsoleServerPortTypeUsbMicrob string = "usb-micro-b"

	// WritableConsoleServerPortTypeOther captures enum value "other"
	WritableConsoleServerPortTypeOther string = "other"
)
View Source 
const (

	// WritableConsoleServerPortTemplateTypeDe9 captures enum value "de-9"
	WritableConsoleServerPortTemplateTypeDe9 string = "de-9"

	// WritableConsoleServerPortTemplateTypeDb25 captures enum value "db-25"
	WritableConsoleServerPortTemplateTypeDb25 string = "db-25"

	// WritableConsoleServerPortTemplateTypeRj11 captures enum value "rj-11"
	WritableConsoleServerPortTemplateTypeRj11 string = "rj-11"

	// WritableConsoleServerPortTemplateTypeRj12 captures enum value "rj-12"
	WritableConsoleServerPortTemplateTypeRj12 string = "rj-12"

	// WritableConsoleServerPortTemplateTypeRj45 captures enum value "rj-45"
	WritableConsoleServerPortTemplateTypeRj45 string = "rj-45"

	// WritableConsoleServerPortTemplateTypeUsba captures enum value "usb-a"
	WritableConsoleServerPortTemplateTypeUsba string = "usb-a"

	// WritableConsoleServerPortTemplateTypeUsbb captures enum value "usb-b"
	WritableConsoleServerPortTemplateTypeUsbb string = "usb-b"

	// WritableConsoleServerPortTemplateTypeUsbc captures enum value "usb-c"
	WritableConsoleServerPortTemplateTypeUsbc string = "usb-c"

	// WritableConsoleServerPortTemplateTypeUsbMinia captures enum value "usb-mini-a"
	WritableConsoleServerPortTemplateTypeUsbMinia string = "usb-mini-a"

	// WritableConsoleServerPortTemplateTypeUsbMinib captures enum value "usb-mini-b"
	WritableConsoleServerPortTemplateTypeUsbMinib string = "usb-mini-b"

	// WritableConsoleServerPortTemplateTypeUsbMicroa captures enum value "usb-micro-a"
	WritableConsoleServerPortTemplateTypeUsbMicroa string = "usb-micro-a"

	// WritableConsoleServerPortTemplateTypeUsbMicrob captures enum value "usb-micro-b"
	WritableConsoleServerPortTemplateTypeUsbMicrob string = "usb-micro-b"

	// WritableConsoleServerPortTemplateTypeOther captures enum value "other"
	WritableConsoleServerPortTemplateTypeOther string = "other"
)
View Source 
const (

	// WritableDeviceInterfaceModeAccess captures enum value "access"
	WritableDeviceInterfaceModeAccess string = "access"

	// WritableDeviceInterfaceModeTagged captures enum value "tagged"
	WritableDeviceInterfaceModeTagged string = "tagged"

	// WritableDeviceInterfaceModeTaggedAll captures enum value "tagged-all"
	WritableDeviceInterfaceModeTaggedAll string = "tagged-all"
)
View Source 
const (

	// WritableDeviceInterfaceTypeVirtual captures enum value "virtual"
	WritableDeviceInterfaceTypeVirtual string = "virtual"

	// WritableDeviceInterfaceTypeLag captures enum value "lag"
	WritableDeviceInterfaceTypeLag string = "lag"

	// WritableDeviceInterfaceTypeNr100baseTx captures enum value "100base-tx"
	WritableDeviceInterfaceTypeNr100baseTx string = "100base-tx"

	// WritableDeviceInterfaceTypeNr1000baset captures enum value "1000base-t"
	WritableDeviceInterfaceTypeNr1000baset string = "1000base-t"

	// WritableDeviceInterfaceTypeNr25gbaset captures enum value "2.5gbase-t"
	WritableDeviceInterfaceTypeNr25gbaset string = "2.5gbase-t"

	// WritableDeviceInterfaceTypeNr5gbaset captures enum value "5gbase-t"
	WritableDeviceInterfaceTypeNr5gbaset string = "5gbase-t"

	// WritableDeviceInterfaceTypeNr10gbaset captures enum value "10gbase-t"
	WritableDeviceInterfaceTypeNr10gbaset string = "10gbase-t"

	// WritableDeviceInterfaceTypeNr10gbaseCx4 captures enum value "10gbase-cx4"
	WritableDeviceInterfaceTypeNr10gbaseCx4 string = "10gbase-cx4"

	// WritableDeviceInterfaceTypeNr1000basexGbic captures enum value "1000base-x-gbic"
	WritableDeviceInterfaceTypeNr1000basexGbic string = "1000base-x-gbic"

	// WritableDeviceInterfaceTypeNr1000basexSfp captures enum value "1000base-x-sfp"
	WritableDeviceInterfaceTypeNr1000basexSfp string = "1000base-x-sfp"

	// WritableDeviceInterfaceTypeNr10gbasexSfpp captures enum value "10gbase-x-sfpp"
	WritableDeviceInterfaceTypeNr10gbasexSfpp string = "10gbase-x-sfpp"

	// WritableDeviceInterfaceTypeNr10gbasexXfp captures enum value "10gbase-x-xfp"
	WritableDeviceInterfaceTypeNr10gbasexXfp string = "10gbase-x-xfp"

	// WritableDeviceInterfaceTypeNr10gbasexXenpak captures enum value "10gbase-x-xenpak"
	WritableDeviceInterfaceTypeNr10gbasexXenpak string = "10gbase-x-xenpak"

	// WritableDeviceInterfaceTypeNr10gbasexX2 captures enum value "10gbase-x-x2"
	WritableDeviceInterfaceTypeNr10gbasexX2 string = "10gbase-x-x2"

	// WritableDeviceInterfaceTypeNr25gbasexSfp28 captures enum value "25gbase-x-sfp28"
	WritableDeviceInterfaceTypeNr25gbasexSfp28 string = "25gbase-x-sfp28"

	// WritableDeviceInterfaceTypeNr40gbasexQsfpp captures enum value "40gbase-x-qsfpp"
	WritableDeviceInterfaceTypeNr40gbasexQsfpp string = "40gbase-x-qsfpp"

	// WritableDeviceInterfaceTypeNr50gbasexSfp28 captures enum value "50gbase-x-sfp28"
	WritableDeviceInterfaceTypeNr50gbasexSfp28 string = "50gbase-x-sfp28"

	// WritableDeviceInterfaceTypeNr100gbasexCfp captures enum value "100gbase-x-cfp"
	WritableDeviceInterfaceTypeNr100gbasexCfp string = "100gbase-x-cfp"

	// WritableDeviceInterfaceTypeNr100gbasexCfp2 captures enum value "100gbase-x-cfp2"
	WritableDeviceInterfaceTypeNr100gbasexCfp2 string = "100gbase-x-cfp2"

	// WritableDeviceInterfaceTypeNr200gbasexCfp2 captures enum value "200gbase-x-cfp2"
	WritableDeviceInterfaceTypeNr200gbasexCfp2 string = "200gbase-x-cfp2"

	// WritableDeviceInterfaceTypeNr100gbasexCfp4 captures enum value "100gbase-x-cfp4"
	WritableDeviceInterfaceTypeNr100gbasexCfp4 string = "100gbase-x-cfp4"

	// WritableDeviceInterfaceTypeNr100gbasexCpak captures enum value "100gbase-x-cpak"
	WritableDeviceInterfaceTypeNr100gbasexCpak string = "100gbase-x-cpak"

	// WritableDeviceInterfaceTypeNr100gbasexQsfp28 captures enum value "100gbase-x-qsfp28"
	WritableDeviceInterfaceTypeNr100gbasexQsfp28 string = "100gbase-x-qsfp28"

	// WritableDeviceInterfaceTypeNr200gbasexQsfp56 captures enum value "200gbase-x-qsfp56"
	WritableDeviceInterfaceTypeNr200gbasexQsfp56 string = "200gbase-x-qsfp56"

	// WritableDeviceInterfaceTypeNr400gbasexQsfpdd captures enum value "400gbase-x-qsfpdd"
	WritableDeviceInterfaceTypeNr400gbasexQsfpdd string = "400gbase-x-qsfpdd"

	// WritableDeviceInterfaceTypeNr400gbasexOsfp captures enum value "400gbase-x-osfp"
	WritableDeviceInterfaceTypeNr400gbasexOsfp string = "400gbase-x-osfp"

	// WritableDeviceInterfaceTypeIeee80211a captures enum value "ieee802.11a"
	WritableDeviceInterfaceTypeIeee80211a string = "ieee802.11a"

	// WritableDeviceInterfaceTypeIeee80211g captures enum value "ieee802.11g"
	WritableDeviceInterfaceTypeIeee80211g string = "ieee802.11g"

	// WritableDeviceInterfaceTypeIeee80211n captures enum value "ieee802.11n"
	WritableDeviceInterfaceTypeIeee80211n string = "ieee802.11n"

	// WritableDeviceInterfaceTypeIeee80211ac captures enum value "ieee802.11ac"
	WritableDeviceInterfaceTypeIeee80211ac string = "ieee802.11ac"

	// WritableDeviceInterfaceTypeIeee80211ad captures enum value "ieee802.11ad"
	WritableDeviceInterfaceTypeIeee80211ad string = "ieee802.11ad"

	// WritableDeviceInterfaceTypeIeee80211ax captures enum value "ieee802.11ax"
	WritableDeviceInterfaceTypeIeee80211ax string = "ieee802.11ax"

	// WritableDeviceInterfaceTypeGsm captures enum value "gsm"
	WritableDeviceInterfaceTypeGsm string = "gsm"

	// WritableDeviceInterfaceTypeCdma captures enum value "cdma"
	WritableDeviceInterfaceTypeCdma string = "cdma"

	// WritableDeviceInterfaceTypeLte captures enum value "lte"
	WritableDeviceInterfaceTypeLte string = "lte"

	// WritableDeviceInterfaceTypeSonetOc3 captures enum value "sonet-oc3"
	WritableDeviceInterfaceTypeSonetOc3 string = "sonet-oc3"

	// WritableDeviceInterfaceTypeSonetOc12 captures enum value "sonet-oc12"
	WritableDeviceInterfaceTypeSonetOc12 string = "sonet-oc12"

	// WritableDeviceInterfaceTypeSonetOc48 captures enum value "sonet-oc48"
	WritableDeviceInterfaceTypeSonetOc48 string = "sonet-oc48"

	// WritableDeviceInterfaceTypeSonetOc192 captures enum value "sonet-oc192"
	WritableDeviceInterfaceTypeSonetOc192 string = "sonet-oc192"

	// WritableDeviceInterfaceTypeSonetOc768 captures enum value "sonet-oc768"
	WritableDeviceInterfaceTypeSonetOc768 string = "sonet-oc768"

	// WritableDeviceInterfaceTypeSonetOc1920 captures enum value "sonet-oc1920"
	WritableDeviceInterfaceTypeSonetOc1920 string = "sonet-oc1920"

	// WritableDeviceInterfaceTypeSonetOc3840 captures enum value "sonet-oc3840"
	WritableDeviceInterfaceTypeSonetOc3840 string = "sonet-oc3840"

	// WritableDeviceInterfaceTypeNr1gfcSfp captures enum value "1gfc-sfp"
	WritableDeviceInterfaceTypeNr1gfcSfp string = "1gfc-sfp"

	// WritableDeviceInterfaceTypeNr2gfcSfp captures enum value "2gfc-sfp"
	WritableDeviceInterfaceTypeNr2gfcSfp string = "2gfc-sfp"

	// WritableDeviceInterfaceTypeNr4gfcSfp captures enum value "4gfc-sfp"
	WritableDeviceInterfaceTypeNr4gfcSfp string = "4gfc-sfp"

	// WritableDeviceInterfaceTypeNr8gfcSfpp captures enum value "8gfc-sfpp"
	WritableDeviceInterfaceTypeNr8gfcSfpp string = "8gfc-sfpp"

	// WritableDeviceInterfaceTypeNr16gfcSfpp captures enum value "16gfc-sfpp"
	WritableDeviceInterfaceTypeNr16gfcSfpp string = "16gfc-sfpp"

	// WritableDeviceInterfaceTypeNr32gfcSfp28 captures enum value "32gfc-sfp28"
	WritableDeviceInterfaceTypeNr32gfcSfp28 string = "32gfc-sfp28"

	// WritableDeviceInterfaceTypeNr128gfcSfp28 captures enum value "128gfc-sfp28"
	WritableDeviceInterfaceTypeNr128gfcSfp28 string = "128gfc-sfp28"

	// WritableDeviceInterfaceTypeInifibandSdr captures enum value "inifiband-sdr"
	WritableDeviceInterfaceTypeInifibandSdr string = "inifiband-sdr"

	// WritableDeviceInterfaceTypeInifibandDdr captures enum value "inifiband-ddr"
	WritableDeviceInterfaceTypeInifibandDdr string = "inifiband-ddr"

	// WritableDeviceInterfaceTypeInifibandQdr captures enum value "inifiband-qdr"
	WritableDeviceInterfaceTypeInifibandQdr string = "inifiband-qdr"

	// WritableDeviceInterfaceTypeInifibandFdr10 captures enum value "inifiband-fdr10"
	WritableDeviceInterfaceTypeInifibandFdr10 string = "inifiband-fdr10"

	// WritableDeviceInterfaceTypeInifibandFdr captures enum value "inifiband-fdr"
	WritableDeviceInterfaceTypeInifibandFdr string = "inifiband-fdr"

	// WritableDeviceInterfaceTypeInifibandEdr captures enum value "inifiband-edr"
	WritableDeviceInterfaceTypeInifibandEdr string = "inifiband-edr"

	// WritableDeviceInterfaceTypeInifibandHdr captures enum value "inifiband-hdr"
	WritableDeviceInterfaceTypeInifibandHdr string = "inifiband-hdr"

	// WritableDeviceInterfaceTypeInifibandNdr captures enum value "inifiband-ndr"
	WritableDeviceInterfaceTypeInifibandNdr string = "inifiband-ndr"

	// WritableDeviceInterfaceTypeInifibandXdr captures enum value "inifiband-xdr"
	WritableDeviceInterfaceTypeInifibandXdr string = "inifiband-xdr"

	// WritableDeviceInterfaceTypeT1 captures enum value "t1"
	WritableDeviceInterfaceTypeT1 string = "t1"

	// WritableDeviceInterfaceTypeE1 captures enum value "e1"
	WritableDeviceInterfaceTypeE1 string = "e1"

	// WritableDeviceInterfaceTypeT3 captures enum value "t3"
	WritableDeviceInterfaceTypeT3 string = "t3"

	// WritableDeviceInterfaceTypeE3 captures enum value "e3"
	WritableDeviceInterfaceTypeE3 string = "e3"

	// WritableDeviceInterfaceTypeCiscoStackwise captures enum value "cisco-stackwise"
	WritableDeviceInterfaceTypeCiscoStackwise string = "cisco-stackwise"

	// WritableDeviceInterfaceTypeCiscoStackwisePlus captures enum value "cisco-stackwise-plus"
	WritableDeviceInterfaceTypeCiscoStackwisePlus string = "cisco-stackwise-plus"

	// WritableDeviceInterfaceTypeCiscoFlexstack captures enum value "cisco-flexstack"
	WritableDeviceInterfaceTypeCiscoFlexstack string = "cisco-flexstack"

	// WritableDeviceInterfaceTypeCiscoFlexstackPlus captures enum value "cisco-flexstack-plus"
	WritableDeviceInterfaceTypeCiscoFlexstackPlus string = "cisco-flexstack-plus"

	// WritableDeviceInterfaceTypeJuniperVcp captures enum value "juniper-vcp"
	WritableDeviceInterfaceTypeJuniperVcp string = "juniper-vcp"

	// WritableDeviceInterfaceTypeExtremeSummitstack captures enum value "extreme-summitstack"
	WritableDeviceInterfaceTypeExtremeSummitstack string = "extreme-summitstack"

	// WritableDeviceInterfaceTypeExtremeSummitstack128 captures enum value "extreme-summitstack-128"
	WritableDeviceInterfaceTypeExtremeSummitstack128 string = "extreme-summitstack-128"

	// WritableDeviceInterfaceTypeExtremeSummitstack256 captures enum value "extreme-summitstack-256"
	WritableDeviceInterfaceTypeExtremeSummitstack256 string = "extreme-summitstack-256"

	// WritableDeviceInterfaceTypeExtremeSummitstack512 captures enum value "extreme-summitstack-512"
	WritableDeviceInterfaceTypeExtremeSummitstack512 string = "extreme-summitstack-512"

	// WritableDeviceInterfaceTypeOther captures enum value "other"
	WritableDeviceInterfaceTypeOther string = "other"
)
View Source 
const (

	// WritableDeviceTypeSubdeviceRoleParent captures enum value "parent"
	WritableDeviceTypeSubdeviceRoleParent string = "parent"

	// WritableDeviceTypeSubdeviceRoleChild captures enum value "child"
	WritableDeviceTypeSubdeviceRoleChild string = "child"
)
View Source 
const (

	// WritableDeviceWithConfigContextFaceFront captures enum value "front"
	WritableDeviceWithConfigContextFaceFront string = "front"

	// WritableDeviceWithConfigContextFaceRear captures enum value "rear"
	WritableDeviceWithConfigContextFaceRear string = "rear"
)
View Source 
const (

	// WritableDeviceWithConfigContextStatusOffline captures enum value "offline"
	WritableDeviceWithConfigContextStatusOffline string = "offline"

	// WritableDeviceWithConfigContextStatusActive captures enum value "active"
	WritableDeviceWithConfigContextStatusActive string = "active"

	// WritableDeviceWithConfigContextStatusPlanned captures enum value "planned"
	WritableDeviceWithConfigContextStatusPlanned string = "planned"

	// WritableDeviceWithConfigContextStatusStaged captures enum value "staged"
	WritableDeviceWithConfigContextStatusStaged string = "staged"

	// WritableDeviceWithConfigContextStatusFailed captures enum value "failed"
	WritableDeviceWithConfigContextStatusFailed string = "failed"

	// WritableDeviceWithConfigContextStatusInventory captures enum value "inventory"
	WritableDeviceWithConfigContextStatusInventory string = "inventory"

	// WritableDeviceWithConfigContextStatusDecommissioning captures enum value "decommissioning"
	WritableDeviceWithConfigContextStatusDecommissioning string = "decommissioning"
)
View Source 
const (

	// WritableExportTemplateTemplateLanguageDjango captures enum value "django"
	WritableExportTemplateTemplateLanguageDjango string = "django"

	// WritableExportTemplateTemplateLanguageJinja2 captures enum value "jinja2"
	WritableExportTemplateTemplateLanguageJinja2 string = "jinja2"
)
View Source 
const (

	// WritableFrontPortTypeNr8p8c captures enum value "8p8c"
	WritableFrontPortTypeNr8p8c string = "8p8c"

	// WritableFrontPortTypeNr110Punch captures enum value "110-punch"
	WritableFrontPortTypeNr110Punch string = "110-punch"

	// WritableFrontPortTypeBnc captures enum value "bnc"
	WritableFrontPortTypeBnc string = "bnc"

	// WritableFrontPortTypeFc captures enum value "fc"
	WritableFrontPortTypeFc string = "fc"

	// WritableFrontPortTypeLc captures enum value "lc"
	WritableFrontPortTypeLc string = "lc"

	// WritableFrontPortTypeLcApc captures enum value "lc-apc"
	WritableFrontPortTypeLcApc string = "lc-apc"

	// WritableFrontPortTypeLsh captures enum value "lsh"
	WritableFrontPortTypeLsh string = "lsh"

	// WritableFrontPortTypeLshApc captures enum value "lsh-apc"
	WritableFrontPortTypeLshApc string = "lsh-apc"

	// WritableFrontPortTypeMpo captures enum value "mpo"
	WritableFrontPortTypeMpo string = "mpo"

	// WritableFrontPortTypeMtrj captures enum value "mtrj"
	WritableFrontPortTypeMtrj string = "mtrj"

	// WritableFrontPortTypeSc captures enum value "sc"
	WritableFrontPortTypeSc string = "sc"

	// WritableFrontPortTypeScApc captures enum value "sc-apc"
	WritableFrontPortTypeScApc string = "sc-apc"

	// WritableFrontPortTypeSt captures enum value "st"
	WritableFrontPortTypeSt string = "st"
)
View Source 
const (

	// WritableFrontPortTemplateTypeNr8p8c captures enum value "8p8c"
	WritableFrontPortTemplateTypeNr8p8c string = "8p8c"

	// WritableFrontPortTemplateTypeNr110Punch captures enum value "110-punch"
	WritableFrontPortTemplateTypeNr110Punch string = "110-punch"

	// WritableFrontPortTemplateTypeBnc captures enum value "bnc"
	WritableFrontPortTemplateTypeBnc string = "bnc"

	// WritableFrontPortTemplateTypeFc captures enum value "fc"
	WritableFrontPortTemplateTypeFc string = "fc"

	// WritableFrontPortTemplateTypeLc captures enum value "lc"
	WritableFrontPortTemplateTypeLc string = "lc"

	// WritableFrontPortTemplateTypeLcApc captures enum value "lc-apc"
	WritableFrontPortTemplateTypeLcApc string = "lc-apc"

	// WritableFrontPortTemplateTypeLsh captures enum value "lsh"
	WritableFrontPortTemplateTypeLsh string = "lsh"

	// WritableFrontPortTemplateTypeLshApc captures enum value "lsh-apc"
	WritableFrontPortTemplateTypeLshApc string = "lsh-apc"

	// WritableFrontPortTemplateTypeMpo captures enum value "mpo"
	WritableFrontPortTemplateTypeMpo string = "mpo"

	// WritableFrontPortTemplateTypeMtrj captures enum value "mtrj"
	WritableFrontPortTemplateTypeMtrj string = "mtrj"

	// WritableFrontPortTemplateTypeSc captures enum value "sc"
	WritableFrontPortTemplateTypeSc string = "sc"

	// WritableFrontPortTemplateTypeScApc captures enum value "sc-apc"
	WritableFrontPortTemplateTypeScApc string = "sc-apc"

	// WritableFrontPortTemplateTypeSt captures enum value "st"
	WritableFrontPortTemplateTypeSt string = "st"
)
View Source 
const (

	// WritableInterfaceTemplateTypeVirtual captures enum value "virtual"
	WritableInterfaceTemplateTypeVirtual string = "virtual"

	// WritableInterfaceTemplateTypeLag captures enum value "lag"
	WritableInterfaceTemplateTypeLag string = "lag"

	// WritableInterfaceTemplateTypeNr100baseTx captures enum value "100base-tx"
	WritableInterfaceTemplateTypeNr100baseTx string = "100base-tx"

	// WritableInterfaceTemplateTypeNr1000baset captures enum value "1000base-t"
	WritableInterfaceTemplateTypeNr1000baset string = "1000base-t"

	// WritableInterfaceTemplateTypeNr25gbaset captures enum value "2.5gbase-t"
	WritableInterfaceTemplateTypeNr25gbaset string = "2.5gbase-t"

	// WritableInterfaceTemplateTypeNr5gbaset captures enum value "5gbase-t"
	WritableInterfaceTemplateTypeNr5gbaset string = "5gbase-t"

	// WritableInterfaceTemplateTypeNr10gbaset captures enum value "10gbase-t"
	WritableInterfaceTemplateTypeNr10gbaset string = "10gbase-t"

	// WritableInterfaceTemplateTypeNr10gbaseCx4 captures enum value "10gbase-cx4"
	WritableInterfaceTemplateTypeNr10gbaseCx4 string = "10gbase-cx4"

	// WritableInterfaceTemplateTypeNr1000basexGbic captures enum value "1000base-x-gbic"
	WritableInterfaceTemplateTypeNr1000basexGbic string = "1000base-x-gbic"

	// WritableInterfaceTemplateTypeNr1000basexSfp captures enum value "1000base-x-sfp"
	WritableInterfaceTemplateTypeNr1000basexSfp string = "1000base-x-sfp"

	// WritableInterfaceTemplateTypeNr10gbasexSfpp captures enum value "10gbase-x-sfpp"
	WritableInterfaceTemplateTypeNr10gbasexSfpp string = "10gbase-x-sfpp"

	// WritableInterfaceTemplateTypeNr10gbasexXfp captures enum value "10gbase-x-xfp"
	WritableInterfaceTemplateTypeNr10gbasexXfp string = "10gbase-x-xfp"

	// WritableInterfaceTemplateTypeNr10gbasexXenpak captures enum value "10gbase-x-xenpak"
	WritableInterfaceTemplateTypeNr10gbasexXenpak string = "10gbase-x-xenpak"

	// WritableInterfaceTemplateTypeNr10gbasexX2 captures enum value "10gbase-x-x2"
	WritableInterfaceTemplateTypeNr10gbasexX2 string = "10gbase-x-x2"

	// WritableInterfaceTemplateTypeNr25gbasexSfp28 captures enum value "25gbase-x-sfp28"
	WritableInterfaceTemplateTypeNr25gbasexSfp28 string = "25gbase-x-sfp28"

	// WritableInterfaceTemplateTypeNr40gbasexQsfpp captures enum value "40gbase-x-qsfpp"
	WritableInterfaceTemplateTypeNr40gbasexQsfpp string = "40gbase-x-qsfpp"

	// WritableInterfaceTemplateTypeNr50gbasexSfp28 captures enum value "50gbase-x-sfp28"
	WritableInterfaceTemplateTypeNr50gbasexSfp28 string = "50gbase-x-sfp28"

	// WritableInterfaceTemplateTypeNr100gbasexCfp captures enum value "100gbase-x-cfp"
	WritableInterfaceTemplateTypeNr100gbasexCfp string = "100gbase-x-cfp"

	// WritableInterfaceTemplateTypeNr100gbasexCfp2 captures enum value "100gbase-x-cfp2"
	WritableInterfaceTemplateTypeNr100gbasexCfp2 string = "100gbase-x-cfp2"

	// WritableInterfaceTemplateTypeNr200gbasexCfp2 captures enum value "200gbase-x-cfp2"
	WritableInterfaceTemplateTypeNr200gbasexCfp2 string = "200gbase-x-cfp2"

	// WritableInterfaceTemplateTypeNr100gbasexCfp4 captures enum value "100gbase-x-cfp4"
	WritableInterfaceTemplateTypeNr100gbasexCfp4 string = "100gbase-x-cfp4"

	// WritableInterfaceTemplateTypeNr100gbasexCpak captures enum value "100gbase-x-cpak"
	WritableInterfaceTemplateTypeNr100gbasexCpak string = "100gbase-x-cpak"

	// WritableInterfaceTemplateTypeNr100gbasexQsfp28 captures enum value "100gbase-x-qsfp28"
	WritableInterfaceTemplateTypeNr100gbasexQsfp28 string = "100gbase-x-qsfp28"

	// WritableInterfaceTemplateTypeNr200gbasexQsfp56 captures enum value "200gbase-x-qsfp56"
	WritableInterfaceTemplateTypeNr200gbasexQsfp56 string = "200gbase-x-qsfp56"

	// WritableInterfaceTemplateTypeNr400gbasexQsfpdd captures enum value "400gbase-x-qsfpdd"
	WritableInterfaceTemplateTypeNr400gbasexQsfpdd string = "400gbase-x-qsfpdd"

	// WritableInterfaceTemplateTypeNr400gbasexOsfp captures enum value "400gbase-x-osfp"
	WritableInterfaceTemplateTypeNr400gbasexOsfp string = "400gbase-x-osfp"

	// WritableInterfaceTemplateTypeIeee80211a captures enum value "ieee802.11a"
	WritableInterfaceTemplateTypeIeee80211a string = "ieee802.11a"

	// WritableInterfaceTemplateTypeIeee80211g captures enum value "ieee802.11g"
	WritableInterfaceTemplateTypeIeee80211g string = "ieee802.11g"

	// WritableInterfaceTemplateTypeIeee80211n captures enum value "ieee802.11n"
	WritableInterfaceTemplateTypeIeee80211n string = "ieee802.11n"

	// WritableInterfaceTemplateTypeIeee80211ac captures enum value "ieee802.11ac"
	WritableInterfaceTemplateTypeIeee80211ac string = "ieee802.11ac"

	// WritableInterfaceTemplateTypeIeee80211ad captures enum value "ieee802.11ad"
	WritableInterfaceTemplateTypeIeee80211ad string = "ieee802.11ad"

	// WritableInterfaceTemplateTypeIeee80211ax captures enum value "ieee802.11ax"
	WritableInterfaceTemplateTypeIeee80211ax string = "ieee802.11ax"

	// WritableInterfaceTemplateTypeGsm captures enum value "gsm"
	WritableInterfaceTemplateTypeGsm string = "gsm"

	// WritableInterfaceTemplateTypeCdma captures enum value "cdma"
	WritableInterfaceTemplateTypeCdma string = "cdma"

	// WritableInterfaceTemplateTypeLte captures enum value "lte"
	WritableInterfaceTemplateTypeLte string = "lte"

	// WritableInterfaceTemplateTypeSonetOc3 captures enum value "sonet-oc3"
	WritableInterfaceTemplateTypeSonetOc3 string = "sonet-oc3"

	// WritableInterfaceTemplateTypeSonetOc12 captures enum value "sonet-oc12"
	WritableInterfaceTemplateTypeSonetOc12 string = "sonet-oc12"

	// WritableInterfaceTemplateTypeSonetOc48 captures enum value "sonet-oc48"
	WritableInterfaceTemplateTypeSonetOc48 string = "sonet-oc48"

	// WritableInterfaceTemplateTypeSonetOc192 captures enum value "sonet-oc192"
	WritableInterfaceTemplateTypeSonetOc192 string = "sonet-oc192"

	// WritableInterfaceTemplateTypeSonetOc768 captures enum value "sonet-oc768"
	WritableInterfaceTemplateTypeSonetOc768 string = "sonet-oc768"

	// WritableInterfaceTemplateTypeSonetOc1920 captures enum value "sonet-oc1920"
	WritableInterfaceTemplateTypeSonetOc1920 string = "sonet-oc1920"

	// WritableInterfaceTemplateTypeSonetOc3840 captures enum value "sonet-oc3840"
	WritableInterfaceTemplateTypeSonetOc3840 string = "sonet-oc3840"

	// WritableInterfaceTemplateTypeNr1gfcSfp captures enum value "1gfc-sfp"
	WritableInterfaceTemplateTypeNr1gfcSfp string = "1gfc-sfp"

	// WritableInterfaceTemplateTypeNr2gfcSfp captures enum value "2gfc-sfp"
	WritableInterfaceTemplateTypeNr2gfcSfp string = "2gfc-sfp"

	// WritableInterfaceTemplateTypeNr4gfcSfp captures enum value "4gfc-sfp"
	WritableInterfaceTemplateTypeNr4gfcSfp string = "4gfc-sfp"

	// WritableInterfaceTemplateTypeNr8gfcSfpp captures enum value "8gfc-sfpp"
	WritableInterfaceTemplateTypeNr8gfcSfpp string = "8gfc-sfpp"

	// WritableInterfaceTemplateTypeNr16gfcSfpp captures enum value "16gfc-sfpp"
	WritableInterfaceTemplateTypeNr16gfcSfpp string = "16gfc-sfpp"

	// WritableInterfaceTemplateTypeNr32gfcSfp28 captures enum value "32gfc-sfp28"
	WritableInterfaceTemplateTypeNr32gfcSfp28 string = "32gfc-sfp28"

	// WritableInterfaceTemplateTypeNr128gfcSfp28 captures enum value "128gfc-sfp28"
	WritableInterfaceTemplateTypeNr128gfcSfp28 string = "128gfc-sfp28"

	// WritableInterfaceTemplateTypeInifibandSdr captures enum value "inifiband-sdr"
	WritableInterfaceTemplateTypeInifibandSdr string = "inifiband-sdr"

	// WritableInterfaceTemplateTypeInifibandDdr captures enum value "inifiband-ddr"
	WritableInterfaceTemplateTypeInifibandDdr string = "inifiband-ddr"

	// WritableInterfaceTemplateTypeInifibandQdr captures enum value "inifiband-qdr"
	WritableInterfaceTemplateTypeInifibandQdr string = "inifiband-qdr"

	// WritableInterfaceTemplateTypeInifibandFdr10 captures enum value "inifiband-fdr10"
	WritableInterfaceTemplateTypeInifibandFdr10 string = "inifiband-fdr10"

	// WritableInterfaceTemplateTypeInifibandFdr captures enum value "inifiband-fdr"
	WritableInterfaceTemplateTypeInifibandFdr string = "inifiband-fdr"

	// WritableInterfaceTemplateTypeInifibandEdr captures enum value "inifiband-edr"
	WritableInterfaceTemplateTypeInifibandEdr string = "inifiband-edr"

	// WritableInterfaceTemplateTypeInifibandHdr captures enum value "inifiband-hdr"
	WritableInterfaceTemplateTypeInifibandHdr string = "inifiband-hdr"

	// WritableInterfaceTemplateTypeInifibandNdr captures enum value "inifiband-ndr"
	WritableInterfaceTemplateTypeInifibandNdr string = "inifiband-ndr"

	// WritableInterfaceTemplateTypeInifibandXdr captures enum value "inifiband-xdr"
	WritableInterfaceTemplateTypeInifibandXdr string = "inifiband-xdr"

	// WritableInterfaceTemplateTypeT1 captures enum value "t1"
	WritableInterfaceTemplateTypeT1 string = "t1"

	// WritableInterfaceTemplateTypeE1 captures enum value "e1"
	WritableInterfaceTemplateTypeE1 string = "e1"

	// WritableInterfaceTemplateTypeT3 captures enum value "t3"
	WritableInterfaceTemplateTypeT3 string = "t3"

	// WritableInterfaceTemplateTypeE3 captures enum value "e3"
	WritableInterfaceTemplateTypeE3 string = "e3"

	// WritableInterfaceTemplateTypeCiscoStackwise captures enum value "cisco-stackwise"
	WritableInterfaceTemplateTypeCiscoStackwise string = "cisco-stackwise"

	// WritableInterfaceTemplateTypeCiscoStackwisePlus captures enum value "cisco-stackwise-plus"
	WritableInterfaceTemplateTypeCiscoStackwisePlus string = "cisco-stackwise-plus"

	// WritableInterfaceTemplateTypeCiscoFlexstack captures enum value "cisco-flexstack"
	WritableInterfaceTemplateTypeCiscoFlexstack string = "cisco-flexstack"

	// WritableInterfaceTemplateTypeCiscoFlexstackPlus captures enum value "cisco-flexstack-plus"
	WritableInterfaceTemplateTypeCiscoFlexstackPlus string = "cisco-flexstack-plus"

	// WritableInterfaceTemplateTypeJuniperVcp captures enum value "juniper-vcp"
	WritableInterfaceTemplateTypeJuniperVcp string = "juniper-vcp"

	// WritableInterfaceTemplateTypeExtremeSummitstack captures enum value "extreme-summitstack"
	WritableInterfaceTemplateTypeExtremeSummitstack string = "extreme-summitstack"

	// WritableInterfaceTemplateTypeExtremeSummitstack128 captures enum value "extreme-summitstack-128"
	WritableInterfaceTemplateTypeExtremeSummitstack128 string = "extreme-summitstack-128"

	// WritableInterfaceTemplateTypeExtremeSummitstack256 captures enum value "extreme-summitstack-256"
	WritableInterfaceTemplateTypeExtremeSummitstack256 string = "extreme-summitstack-256"

	// WritableInterfaceTemplateTypeExtremeSummitstack512 captures enum value "extreme-summitstack-512"
	WritableInterfaceTemplateTypeExtremeSummitstack512 string = "extreme-summitstack-512"

	// WritableInterfaceTemplateTypeOther captures enum value "other"
	WritableInterfaceTemplateTypeOther string = "other"
)
View Source 
const (

	// WritableIPAddressRoleLoopback captures enum value "loopback"
	WritableIPAddressRoleLoopback string = "loopback"

	// WritableIPAddressRoleSecondary captures enum value "secondary"
	WritableIPAddressRoleSecondary string = "secondary"

	// WritableIPAddressRoleAnycast captures enum value "anycast"
	WritableIPAddressRoleAnycast string = "anycast"

	// WritableIPAddressRoleVip captures enum value "vip"
	WritableIPAddressRoleVip string = "vip"

	// WritableIPAddressRoleVrrp captures enum value "vrrp"
	WritableIPAddressRoleVrrp string = "vrrp"

	// WritableIPAddressRoleHsrp captures enum value "hsrp"
	WritableIPAddressRoleHsrp string = "hsrp"

	// WritableIPAddressRoleGlbp captures enum value "glbp"
	WritableIPAddressRoleGlbp string = "glbp"

	// WritableIPAddressRoleCarp captures enum value "carp"
	WritableIPAddressRoleCarp string = "carp"
)
View Source 
const (

	// WritableIPAddressStatusActive captures enum value "active"
	WritableIPAddressStatusActive string = "active"

	// WritableIPAddressStatusReserved captures enum value "reserved"
	WritableIPAddressStatusReserved string = "reserved"

	// WritableIPAddressStatusDeprecated captures enum value "deprecated"
	WritableIPAddressStatusDeprecated string = "deprecated"

	// WritableIPAddressStatusDhcp captures enum value "dhcp"
	WritableIPAddressStatusDhcp string = "dhcp"
)
View Source 
const (

	// WritablePowerFeedPhaseSinglePhase captures enum value "single-phase"
	WritablePowerFeedPhaseSinglePhase string = "single-phase"

	// WritablePowerFeedPhaseThreePhase captures enum value "three-phase"
	WritablePowerFeedPhaseThreePhase string = "three-phase"
)
View Source 
const (

	// WritablePowerFeedStatusOffline captures enum value "offline"
	WritablePowerFeedStatusOffline string = "offline"

	// WritablePowerFeedStatusActive captures enum value "active"
	WritablePowerFeedStatusActive string = "active"

	// WritablePowerFeedStatusPlanned captures enum value "planned"
	WritablePowerFeedStatusPlanned string = "planned"

	// WritablePowerFeedStatusFailed captures enum value "failed"
	WritablePowerFeedStatusFailed string = "failed"
)
View Source 
const (

	// WritablePowerFeedSupplyAc captures enum value "ac"
	WritablePowerFeedSupplyAc string = "ac"

	// WritablePowerFeedSupplyDc captures enum value "dc"
	WritablePowerFeedSupplyDc string = "dc"
)
View Source 
const (

	// WritablePowerFeedTypePrimary captures enum value "primary"
	WritablePowerFeedTypePrimary string = "primary"

	// WritablePowerFeedTypeRedundant captures enum value "redundant"
	WritablePowerFeedTypeRedundant string = "redundant"
)
View Source 
const (

	// WritablePowerOutletFeedLegA captures enum value "A"
	WritablePowerOutletFeedLegA string = "A"

	// WritablePowerOutletFeedLegB captures enum value "B"
	WritablePowerOutletFeedLegB string = "B"

	// WritablePowerOutletFeedLegC captures enum value "C"
	WritablePowerOutletFeedLegC string = "C"
)
View Source 
const (

	// WritablePowerOutletTypeIec60320C5 captures enum value "iec-60320-c5"
	WritablePowerOutletTypeIec60320C5 string = "iec-60320-c5"

	// WritablePowerOutletTypeIec60320C7 captures enum value "iec-60320-c7"
	WritablePowerOutletTypeIec60320C7 string = "iec-60320-c7"

	// WritablePowerOutletTypeIec60320C13 captures enum value "iec-60320-c13"
	WritablePowerOutletTypeIec60320C13 string = "iec-60320-c13"

	// WritablePowerOutletTypeIec60320C15 captures enum value "iec-60320-c15"
	WritablePowerOutletTypeIec60320C15 string = "iec-60320-c15"

	// WritablePowerOutletTypeIec60320C19 captures enum value "iec-60320-c19"
	WritablePowerOutletTypeIec60320C19 string = "iec-60320-c19"

	// WritablePowerOutletTypeIec60309pne4h captures enum value "iec-60309-p-n-e-4h"
	WritablePowerOutletTypeIec60309pne4h string = "iec-60309-p-n-e-4h"

	// WritablePowerOutletTypeIec60309pne6h captures enum value "iec-60309-p-n-e-6h"
	WritablePowerOutletTypeIec60309pne6h string = "iec-60309-p-n-e-6h"

	// WritablePowerOutletTypeIec60309pne9h captures enum value "iec-60309-p-n-e-9h"
	WritablePowerOutletTypeIec60309pne9h string = "iec-60309-p-n-e-9h"

	// WritablePowerOutletTypeIec603092pe4h captures enum value "iec-60309-2p-e-4h"
	WritablePowerOutletTypeIec603092pe4h string = "iec-60309-2p-e-4h"

	// WritablePowerOutletTypeIec603092pe6h captures enum value "iec-60309-2p-e-6h"
	WritablePowerOutletTypeIec603092pe6h string = "iec-60309-2p-e-6h"

	// WritablePowerOutletTypeIec603092pe9h captures enum value "iec-60309-2p-e-9h"
	WritablePowerOutletTypeIec603092pe9h string = "iec-60309-2p-e-9h"

	// WritablePowerOutletTypeIec603093pe4h captures enum value "iec-60309-3p-e-4h"
	WritablePowerOutletTypeIec603093pe4h string = "iec-60309-3p-e-4h"

	// WritablePowerOutletTypeIec603093pe6h captures enum value "iec-60309-3p-e-6h"
	WritablePowerOutletTypeIec603093pe6h string = "iec-60309-3p-e-6h"

	// WritablePowerOutletTypeIec603093pe9h captures enum value "iec-60309-3p-e-9h"
	WritablePowerOutletTypeIec603093pe9h string = "iec-60309-3p-e-9h"

	// WritablePowerOutletTypeIec603093pne4h captures enum value "iec-60309-3p-n-e-4h"
	WritablePowerOutletTypeIec603093pne4h string = "iec-60309-3p-n-e-4h"

	// WritablePowerOutletTypeIec603093pne6h captures enum value "iec-60309-3p-n-e-6h"
	WritablePowerOutletTypeIec603093pne6h string = "iec-60309-3p-n-e-6h"

	// WritablePowerOutletTypeIec603093pne9h captures enum value "iec-60309-3p-n-e-9h"
	WritablePowerOutletTypeIec603093pne9h string = "iec-60309-3p-n-e-9h"

	// WritablePowerOutletTypeNema515r captures enum value "nema-5-15r"
	WritablePowerOutletTypeNema515r string = "nema-5-15r"

	// WritablePowerOutletTypeNema520r captures enum value "nema-5-20r"
	WritablePowerOutletTypeNema520r string = "nema-5-20r"

	// WritablePowerOutletTypeNema530r captures enum value "nema-5-30r"
	WritablePowerOutletTypeNema530r string = "nema-5-30r"

	// WritablePowerOutletTypeNema550r captures enum value "nema-5-50r"
	WritablePowerOutletTypeNema550r string = "nema-5-50r"

	// WritablePowerOutletTypeNema615r captures enum value "nema-6-15r"
	WritablePowerOutletTypeNema615r string = "nema-6-15r"

	// WritablePowerOutletTypeNema620r captures enum value "nema-6-20r"
	WritablePowerOutletTypeNema620r string = "nema-6-20r"

	// WritablePowerOutletTypeNema630r captures enum value "nema-6-30r"
	WritablePowerOutletTypeNema630r string = "nema-6-30r"

	// WritablePowerOutletTypeNema650r captures enum value "nema-6-50r"
	WritablePowerOutletTypeNema650r string = "nema-6-50r"

	// WritablePowerOutletTypeNemaL515r captures enum value "nema-l5-15r"
	WritablePowerOutletTypeNemaL515r string = "nema-l5-15r"

	// WritablePowerOutletTypeNemaL520r captures enum value "nema-l5-20r"
	WritablePowerOutletTypeNemaL520r string = "nema-l5-20r"

	// WritablePowerOutletTypeNemaL530r captures enum value "nema-l5-30r"
	WritablePowerOutletTypeNemaL530r string = "nema-l5-30r"

	// WritablePowerOutletTypeNemaL550r captures enum value "nema-l5-50r"
	WritablePowerOutletTypeNemaL550r string = "nema-l5-50r"

	// WritablePowerOutletTypeNemaL620r captures enum value "nema-l6-20r"
	WritablePowerOutletTypeNemaL620r string = "nema-l6-20r"

	// WritablePowerOutletTypeNemaL630r captures enum value "nema-l6-30r"
	WritablePowerOutletTypeNemaL630r string = "nema-l6-30r"

	// WritablePowerOutletTypeNemaL650r captures enum value "nema-l6-50r"
	WritablePowerOutletTypeNemaL650r string = "nema-l6-50r"

	// WritablePowerOutletTypeCS6360C captures enum value "CS6360C"
	WritablePowerOutletTypeCS6360C string = "CS6360C"

	// WritablePowerOutletTypeCS6364C captures enum value "CS6364C"
	WritablePowerOutletTypeCS6364C string = "CS6364C"

	// WritablePowerOutletTypeCS8164C captures enum value "CS8164C"
	WritablePowerOutletTypeCS8164C string = "CS8164C"

	// WritablePowerOutletTypeCS8264C captures enum value "CS8264C"
	WritablePowerOutletTypeCS8264C string = "CS8264C"

	// WritablePowerOutletTypeCS8364C captures enum value "CS8364C"
	WritablePowerOutletTypeCS8364C string = "CS8364C"

	// WritablePowerOutletTypeCS8464C captures enum value "CS8464C"
	WritablePowerOutletTypeCS8464C string = "CS8464C"

	// WritablePowerOutletTypeItae captures enum value "ita-e"
	WritablePowerOutletTypeItae string = "ita-e"

	// WritablePowerOutletTypeItaf captures enum value "ita-f"
	WritablePowerOutletTypeItaf string = "ita-f"

	// WritablePowerOutletTypeItag captures enum value "ita-g"
	WritablePowerOutletTypeItag string = "ita-g"

	// WritablePowerOutletTypeItah captures enum value "ita-h"
	WritablePowerOutletTypeItah string = "ita-h"

	// WritablePowerOutletTypeItai captures enum value "ita-i"
	WritablePowerOutletTypeItai string = "ita-i"

	// WritablePowerOutletTypeItaj captures enum value "ita-j"
	WritablePowerOutletTypeItaj string = "ita-j"

	// WritablePowerOutletTypeItak captures enum value "ita-k"
	WritablePowerOutletTypeItak string = "ita-k"

	// WritablePowerOutletTypeItal captures enum value "ita-l"
	WritablePowerOutletTypeItal string = "ita-l"

	// WritablePowerOutletTypeItam captures enum value "ita-m"
	WritablePowerOutletTypeItam string = "ita-m"

	// WritablePowerOutletTypeItan captures enum value "ita-n"
	WritablePowerOutletTypeItan string = "ita-n"

	// WritablePowerOutletTypeItao captures enum value "ita-o"
	WritablePowerOutletTypeItao string = "ita-o"
)
View Source 
const (

	// WritablePowerOutletTemplateFeedLegA captures enum value "A"
	WritablePowerOutletTemplateFeedLegA string = "A"

	// WritablePowerOutletTemplateFeedLegB captures enum value "B"
	WritablePowerOutletTemplateFeedLegB string = "B"

	// WritablePowerOutletTemplateFeedLegC captures enum value "C"
	WritablePowerOutletTemplateFeedLegC string = "C"
)
View Source 
const (

	// WritablePowerOutletTemplateTypeIec60320C5 captures enum value "iec-60320-c5"
	WritablePowerOutletTemplateTypeIec60320C5 string = "iec-60320-c5"

	// WritablePowerOutletTemplateTypeIec60320C7 captures enum value "iec-60320-c7"
	WritablePowerOutletTemplateTypeIec60320C7 string = "iec-60320-c7"

	// WritablePowerOutletTemplateTypeIec60320C13 captures enum value "iec-60320-c13"
	WritablePowerOutletTemplateTypeIec60320C13 string = "iec-60320-c13"

	// WritablePowerOutletTemplateTypeIec60320C15 captures enum value "iec-60320-c15"
	WritablePowerOutletTemplateTypeIec60320C15 string = "iec-60320-c15"

	// WritablePowerOutletTemplateTypeIec60320C19 captures enum value "iec-60320-c19"
	WritablePowerOutletTemplateTypeIec60320C19 string = "iec-60320-c19"

	// WritablePowerOutletTemplateTypeIec60309pne4h captures enum value "iec-60309-p-n-e-4h"
	WritablePowerOutletTemplateTypeIec60309pne4h string = "iec-60309-p-n-e-4h"

	// WritablePowerOutletTemplateTypeIec60309pne6h captures enum value "iec-60309-p-n-e-6h"
	WritablePowerOutletTemplateTypeIec60309pne6h string = "iec-60309-p-n-e-6h"

	// WritablePowerOutletTemplateTypeIec60309pne9h captures enum value "iec-60309-p-n-e-9h"
	WritablePowerOutletTemplateTypeIec60309pne9h string = "iec-60309-p-n-e-9h"

	// WritablePowerOutletTemplateTypeIec603092pe4h captures enum value "iec-60309-2p-e-4h"
	WritablePowerOutletTemplateTypeIec603092pe4h string = "iec-60309-2p-e-4h"

	// WritablePowerOutletTemplateTypeIec603092pe6h captures enum value "iec-60309-2p-e-6h"
	WritablePowerOutletTemplateTypeIec603092pe6h string = "iec-60309-2p-e-6h"

	// WritablePowerOutletTemplateTypeIec603092pe9h captures enum value "iec-60309-2p-e-9h"
	WritablePowerOutletTemplateTypeIec603092pe9h string = "iec-60309-2p-e-9h"

	// WritablePowerOutletTemplateTypeIec603093pe4h captures enum value "iec-60309-3p-e-4h"
	WritablePowerOutletTemplateTypeIec603093pe4h string = "iec-60309-3p-e-4h"

	// WritablePowerOutletTemplateTypeIec603093pe6h captures enum value "iec-60309-3p-e-6h"
	WritablePowerOutletTemplateTypeIec603093pe6h string = "iec-60309-3p-e-6h"

	// WritablePowerOutletTemplateTypeIec603093pe9h captures enum value "iec-60309-3p-e-9h"
	WritablePowerOutletTemplateTypeIec603093pe9h string = "iec-60309-3p-e-9h"

	// WritablePowerOutletTemplateTypeIec603093pne4h captures enum value "iec-60309-3p-n-e-4h"
	WritablePowerOutletTemplateTypeIec603093pne4h string = "iec-60309-3p-n-e-4h"

	// WritablePowerOutletTemplateTypeIec603093pne6h captures enum value "iec-60309-3p-n-e-6h"
	WritablePowerOutletTemplateTypeIec603093pne6h string = "iec-60309-3p-n-e-6h"

	// WritablePowerOutletTemplateTypeIec603093pne9h captures enum value "iec-60309-3p-n-e-9h"
	WritablePowerOutletTemplateTypeIec603093pne9h string = "iec-60309-3p-n-e-9h"

	// WritablePowerOutletTemplateTypeNema515r captures enum value "nema-5-15r"
	WritablePowerOutletTemplateTypeNema515r string = "nema-5-15r"

	// WritablePowerOutletTemplateTypeNema520r captures enum value "nema-5-20r"
	WritablePowerOutletTemplateTypeNema520r string = "nema-5-20r"

	// WritablePowerOutletTemplateTypeNema530r captures enum value "nema-5-30r"
	WritablePowerOutletTemplateTypeNema530r string = "nema-5-30r"

	// WritablePowerOutletTemplateTypeNema550r captures enum value "nema-5-50r"
	WritablePowerOutletTemplateTypeNema550r string = "nema-5-50r"

	// WritablePowerOutletTemplateTypeNema615r captures enum value "nema-6-15r"
	WritablePowerOutletTemplateTypeNema615r string = "nema-6-15r"

	// WritablePowerOutletTemplateTypeNema620r captures enum value "nema-6-20r"
	WritablePowerOutletTemplateTypeNema620r string = "nema-6-20r"

	// WritablePowerOutletTemplateTypeNema630r captures enum value "nema-6-30r"
	WritablePowerOutletTemplateTypeNema630r string = "nema-6-30r"

	// WritablePowerOutletTemplateTypeNema650r captures enum value "nema-6-50r"
	WritablePowerOutletTemplateTypeNema650r string = "nema-6-50r"

	// WritablePowerOutletTemplateTypeNemaL515r captures enum value "nema-l5-15r"
	WritablePowerOutletTemplateTypeNemaL515r string = "nema-l5-15r"

	// WritablePowerOutletTemplateTypeNemaL520r captures enum value "nema-l5-20r"
	WritablePowerOutletTemplateTypeNemaL520r string = "nema-l5-20r"

	// WritablePowerOutletTemplateTypeNemaL530r captures enum value "nema-l5-30r"
	WritablePowerOutletTemplateTypeNemaL530r string = "nema-l5-30r"

	// WritablePowerOutletTemplateTypeNemaL550r captures enum value "nema-l5-50r"
	WritablePowerOutletTemplateTypeNemaL550r string = "nema-l5-50r"

	// WritablePowerOutletTemplateTypeNemaL620r captures enum value "nema-l6-20r"
	WritablePowerOutletTemplateTypeNemaL620r string = "nema-l6-20r"

	// WritablePowerOutletTemplateTypeNemaL630r captures enum value "nema-l6-30r"
	WritablePowerOutletTemplateTypeNemaL630r string = "nema-l6-30r"

	// WritablePowerOutletTemplateTypeNemaL650r captures enum value "nema-l6-50r"
	WritablePowerOutletTemplateTypeNemaL650r string = "nema-l6-50r"

	// WritablePowerOutletTemplateTypeCS6360C captures enum value "CS6360C"
	WritablePowerOutletTemplateTypeCS6360C string = "CS6360C"

	// WritablePowerOutletTemplateTypeCS6364C captures enum value "CS6364C"
	WritablePowerOutletTemplateTypeCS6364C string = "CS6364C"

	// WritablePowerOutletTemplateTypeCS8164C captures enum value "CS8164C"
	WritablePowerOutletTemplateTypeCS8164C string = "CS8164C"

	// WritablePowerOutletTemplateTypeCS8264C captures enum value "CS8264C"
	WritablePowerOutletTemplateTypeCS8264C string = "CS8264C"

	// WritablePowerOutletTemplateTypeCS8364C captures enum value "CS8364C"
	WritablePowerOutletTemplateTypeCS8364C string = "CS8364C"

	// WritablePowerOutletTemplateTypeCS8464C captures enum value "CS8464C"
	WritablePowerOutletTemplateTypeCS8464C string = "CS8464C"

	// WritablePowerOutletTemplateTypeItae captures enum value "ita-e"
	WritablePowerOutletTemplateTypeItae string = "ita-e"

	// WritablePowerOutletTemplateTypeItaf captures enum value "ita-f"
	WritablePowerOutletTemplateTypeItaf string = "ita-f"

	// WritablePowerOutletTemplateTypeItag captures enum value "ita-g"
	WritablePowerOutletTemplateTypeItag string = "ita-g"

	// WritablePowerOutletTemplateTypeItah captures enum value "ita-h"
	WritablePowerOutletTemplateTypeItah string = "ita-h"

	// WritablePowerOutletTemplateTypeItai captures enum value "ita-i"
	WritablePowerOutletTemplateTypeItai string = "ita-i"

	// WritablePowerOutletTemplateTypeItaj captures enum value "ita-j"
	WritablePowerOutletTemplateTypeItaj string = "ita-j"

	// WritablePowerOutletTemplateTypeItak captures enum value "ita-k"
	WritablePowerOutletTemplateTypeItak string = "ita-k"

	// WritablePowerOutletTemplateTypeItal captures enum value "ita-l"
	WritablePowerOutletTemplateTypeItal string = "ita-l"

	// WritablePowerOutletTemplateTypeItam captures enum value "ita-m"
	WritablePowerOutletTemplateTypeItam string = "ita-m"

	// WritablePowerOutletTemplateTypeItan captures enum value "ita-n"
	WritablePowerOutletTemplateTypeItan string = "ita-n"

	// WritablePowerOutletTemplateTypeItao captures enum value "ita-o"
	WritablePowerOutletTemplateTypeItao string = "ita-o"
)
View Source 
const (

	// WritablePowerPortTypeIec60320C6 captures enum value "iec-60320-c6"
	WritablePowerPortTypeIec60320C6 string = "iec-60320-c6"

	// WritablePowerPortTypeIec60320C8 captures enum value "iec-60320-c8"
	WritablePowerPortTypeIec60320C8 string = "iec-60320-c8"

	// WritablePowerPortTypeIec60320C14 captures enum value "iec-60320-c14"
	WritablePowerPortTypeIec60320C14 string = "iec-60320-c14"

	// WritablePowerPortTypeIec60320C16 captures enum value "iec-60320-c16"
	WritablePowerPortTypeIec60320C16 string = "iec-60320-c16"

	// WritablePowerPortTypeIec60320C20 captures enum value "iec-60320-c20"
	WritablePowerPortTypeIec60320C20 string = "iec-60320-c20"

	// WritablePowerPortTypeIec60309pne4h captures enum value "iec-60309-p-n-e-4h"
	WritablePowerPortTypeIec60309pne4h string = "iec-60309-p-n-e-4h"

	// WritablePowerPortTypeIec60309pne6h captures enum value "iec-60309-p-n-e-6h"
	WritablePowerPortTypeIec60309pne6h string = "iec-60309-p-n-e-6h"

	// WritablePowerPortTypeIec60309pne9h captures enum value "iec-60309-p-n-e-9h"
	WritablePowerPortTypeIec60309pne9h string = "iec-60309-p-n-e-9h"

	// WritablePowerPortTypeIec603092pe4h captures enum value "iec-60309-2p-e-4h"
	WritablePowerPortTypeIec603092pe4h string = "iec-60309-2p-e-4h"

	// WritablePowerPortTypeIec603092pe6h captures enum value "iec-60309-2p-e-6h"
	WritablePowerPortTypeIec603092pe6h string = "iec-60309-2p-e-6h"

	// WritablePowerPortTypeIec603092pe9h captures enum value "iec-60309-2p-e-9h"
	WritablePowerPortTypeIec603092pe9h string = "iec-60309-2p-e-9h"

	// WritablePowerPortTypeIec603093pe4h captures enum value "iec-60309-3p-e-4h"
	WritablePowerPortTypeIec603093pe4h string = "iec-60309-3p-e-4h"

	// WritablePowerPortTypeIec603093pe6h captures enum value "iec-60309-3p-e-6h"
	WritablePowerPortTypeIec603093pe6h string = "iec-60309-3p-e-6h"

	// WritablePowerPortTypeIec603093pe9h captures enum value "iec-60309-3p-e-9h"
	WritablePowerPortTypeIec603093pe9h string = "iec-60309-3p-e-9h"

	// WritablePowerPortTypeIec603093pne4h captures enum value "iec-60309-3p-n-e-4h"
	WritablePowerPortTypeIec603093pne4h string = "iec-60309-3p-n-e-4h"

	// WritablePowerPortTypeIec603093pne6h captures enum value "iec-60309-3p-n-e-6h"
	WritablePowerPortTypeIec603093pne6h string = "iec-60309-3p-n-e-6h"

	// WritablePowerPortTypeIec603093pne9h captures enum value "iec-60309-3p-n-e-9h"
	WritablePowerPortTypeIec603093pne9h string = "iec-60309-3p-n-e-9h"

	// WritablePowerPortTypeNema515p captures enum value "nema-5-15p"
	WritablePowerPortTypeNema515p string = "nema-5-15p"

	// WritablePowerPortTypeNema520p captures enum value "nema-5-20p"
	WritablePowerPortTypeNema520p string = "nema-5-20p"

	// WritablePowerPortTypeNema530p captures enum value "nema-5-30p"
	WritablePowerPortTypeNema530p string = "nema-5-30p"

	// WritablePowerPortTypeNema550p captures enum value "nema-5-50p"
	WritablePowerPortTypeNema550p string = "nema-5-50p"

	// WritablePowerPortTypeNema615p captures enum value "nema-6-15p"
	WritablePowerPortTypeNema615p string = "nema-6-15p"

	// WritablePowerPortTypeNema620p captures enum value "nema-6-20p"
	WritablePowerPortTypeNema620p string = "nema-6-20p"

	// WritablePowerPortTypeNema630p captures enum value "nema-6-30p"
	WritablePowerPortTypeNema630p string = "nema-6-30p"

	// WritablePowerPortTypeNema650p captures enum value "nema-6-50p"
	WritablePowerPortTypeNema650p string = "nema-6-50p"

	// WritablePowerPortTypeNemaL515p captures enum value "nema-l5-15p"
	WritablePowerPortTypeNemaL515p string = "nema-l5-15p"

	// WritablePowerPortTypeNemaL520p captures enum value "nema-l5-20p"
	WritablePowerPortTypeNemaL520p string = "nema-l5-20p"

	// WritablePowerPortTypeNemaL530p captures enum value "nema-l5-30p"
	WritablePowerPortTypeNemaL530p string = "nema-l5-30p"

	// WritablePowerPortTypeNemaL550p captures enum value "nema-l5-50p"
	WritablePowerPortTypeNemaL550p string = "nema-l5-50p"

	// WritablePowerPortTypeNemaL620p captures enum value "nema-l6-20p"
	WritablePowerPortTypeNemaL620p string = "nema-l6-20p"

	// WritablePowerPortTypeNemaL630p captures enum value "nema-l6-30p"
	WritablePowerPortTypeNemaL630p string = "nema-l6-30p"

	// WritablePowerPortTypeNemaL650p captures enum value "nema-l6-50p"
	WritablePowerPortTypeNemaL650p string = "nema-l6-50p"

	// WritablePowerPortTypeCs6361c captures enum value "cs6361c"
	WritablePowerPortTypeCs6361c string = "cs6361c"

	// WritablePowerPortTypeCs6365c captures enum value "cs6365c"
	WritablePowerPortTypeCs6365c string = "cs6365c"

	// WritablePowerPortTypeCs8165c captures enum value "cs8165c"
	WritablePowerPortTypeCs8165c string = "cs8165c"

	// WritablePowerPortTypeCs8265c captures enum value "cs8265c"
	WritablePowerPortTypeCs8265c string = "cs8265c"

	// WritablePowerPortTypeCs8365c captures enum value "cs8365c"
	WritablePowerPortTypeCs8365c string = "cs8365c"

	// WritablePowerPortTypeCs8465c captures enum value "cs8465c"
	WritablePowerPortTypeCs8465c string = "cs8465c"

	// WritablePowerPortTypeItae captures enum value "ita-e"
	WritablePowerPortTypeItae string = "ita-e"

	// WritablePowerPortTypeItaf captures enum value "ita-f"
	WritablePowerPortTypeItaf string = "ita-f"

	// WritablePowerPortTypeItaEf captures enum value "ita-ef"
	WritablePowerPortTypeItaEf string = "ita-ef"

	// WritablePowerPortTypeItag captures enum value "ita-g"
	WritablePowerPortTypeItag string = "ita-g"

	// WritablePowerPortTypeItah captures enum value "ita-h"
	WritablePowerPortTypeItah string = "ita-h"

	// WritablePowerPortTypeItai captures enum value "ita-i"
	WritablePowerPortTypeItai string = "ita-i"

	// WritablePowerPortTypeItaj captures enum value "ita-j"
	WritablePowerPortTypeItaj string = "ita-j"

	// WritablePowerPortTypeItak captures enum value "ita-k"
	WritablePowerPortTypeItak string = "ita-k"

	// WritablePowerPortTypeItal captures enum value "ita-l"
	WritablePowerPortTypeItal string = "ita-l"

	// WritablePowerPortTypeItam captures enum value "ita-m"
	WritablePowerPortTypeItam string = "ita-m"

	// WritablePowerPortTypeItan captures enum value "ita-n"
	WritablePowerPortTypeItan string = "ita-n"

	// WritablePowerPortTypeItao captures enum value "ita-o"
	WritablePowerPortTypeItao string = "ita-o"
)
View Source 
const (

	// WritablePowerPortTemplateTypeIec60320C6 captures enum value "iec-60320-c6"
	WritablePowerPortTemplateTypeIec60320C6 string = "iec-60320-c6"

	// WritablePowerPortTemplateTypeIec60320C8 captures enum value "iec-60320-c8"
	WritablePowerPortTemplateTypeIec60320C8 string = "iec-60320-c8"

	// WritablePowerPortTemplateTypeIec60320C14 captures enum value "iec-60320-c14"
	WritablePowerPortTemplateTypeIec60320C14 string = "iec-60320-c14"

	// WritablePowerPortTemplateTypeIec60320C16 captures enum value "iec-60320-c16"
	WritablePowerPortTemplateTypeIec60320C16 string = "iec-60320-c16"

	// WritablePowerPortTemplateTypeIec60320C20 captures enum value "iec-60320-c20"
	WritablePowerPortTemplateTypeIec60320C20 string = "iec-60320-c20"

	// WritablePowerPortTemplateTypeIec60309pne4h captures enum value "iec-60309-p-n-e-4h"
	WritablePowerPortTemplateTypeIec60309pne4h string = "iec-60309-p-n-e-4h"

	// WritablePowerPortTemplateTypeIec60309pne6h captures enum value "iec-60309-p-n-e-6h"
	WritablePowerPortTemplateTypeIec60309pne6h string = "iec-60309-p-n-e-6h"

	// WritablePowerPortTemplateTypeIec60309pne9h captures enum value "iec-60309-p-n-e-9h"
	WritablePowerPortTemplateTypeIec60309pne9h string = "iec-60309-p-n-e-9h"

	// WritablePowerPortTemplateTypeIec603092pe4h captures enum value "iec-60309-2p-e-4h"
	WritablePowerPortTemplateTypeIec603092pe4h string = "iec-60309-2p-e-4h"

	// WritablePowerPortTemplateTypeIec603092pe6h captures enum value "iec-60309-2p-e-6h"
	WritablePowerPortTemplateTypeIec603092pe6h string = "iec-60309-2p-e-6h"

	// WritablePowerPortTemplateTypeIec603092pe9h captures enum value "iec-60309-2p-e-9h"
	WritablePowerPortTemplateTypeIec603092pe9h string = "iec-60309-2p-e-9h"

	// WritablePowerPortTemplateTypeIec603093pe4h captures enum value "iec-60309-3p-e-4h"
	WritablePowerPortTemplateTypeIec603093pe4h string = "iec-60309-3p-e-4h"

	// WritablePowerPortTemplateTypeIec603093pe6h captures enum value "iec-60309-3p-e-6h"
	WritablePowerPortTemplateTypeIec603093pe6h string = "iec-60309-3p-e-6h"

	// WritablePowerPortTemplateTypeIec603093pe9h captures enum value "iec-60309-3p-e-9h"
	WritablePowerPortTemplateTypeIec603093pe9h string = "iec-60309-3p-e-9h"

	// WritablePowerPortTemplateTypeIec603093pne4h captures enum value "iec-60309-3p-n-e-4h"
	WritablePowerPortTemplateTypeIec603093pne4h string = "iec-60309-3p-n-e-4h"

	// WritablePowerPortTemplateTypeIec603093pne6h captures enum value "iec-60309-3p-n-e-6h"
	WritablePowerPortTemplateTypeIec603093pne6h string = "iec-60309-3p-n-e-6h"

	// WritablePowerPortTemplateTypeIec603093pne9h captures enum value "iec-60309-3p-n-e-9h"
	WritablePowerPortTemplateTypeIec603093pne9h string = "iec-60309-3p-n-e-9h"

	// WritablePowerPortTemplateTypeNema515p captures enum value "nema-5-15p"
	WritablePowerPortTemplateTypeNema515p string = "nema-5-15p"

	// WritablePowerPortTemplateTypeNema520p captures enum value "nema-5-20p"
	WritablePowerPortTemplateTypeNema520p string = "nema-5-20p"

	// WritablePowerPortTemplateTypeNema530p captures enum value "nema-5-30p"
	WritablePowerPortTemplateTypeNema530p string = "nema-5-30p"

	// WritablePowerPortTemplateTypeNema550p captures enum value "nema-5-50p"
	WritablePowerPortTemplateTypeNema550p string = "nema-5-50p"

	// WritablePowerPortTemplateTypeNema615p captures enum value "nema-6-15p"
	WritablePowerPortTemplateTypeNema615p string = "nema-6-15p"

	// WritablePowerPortTemplateTypeNema620p captures enum value "nema-6-20p"
	WritablePowerPortTemplateTypeNema620p string = "nema-6-20p"

	// WritablePowerPortTemplateTypeNema630p captures enum value "nema-6-30p"
	WritablePowerPortTemplateTypeNema630p string = "nema-6-30p"

	// WritablePowerPortTemplateTypeNema650p captures enum value "nema-6-50p"
	WritablePowerPortTemplateTypeNema650p string = "nema-6-50p"

	// WritablePowerPortTemplateTypeNemaL515p captures enum value "nema-l5-15p"
	WritablePowerPortTemplateTypeNemaL515p string = "nema-l5-15p"

	// WritablePowerPortTemplateTypeNemaL520p captures enum value "nema-l5-20p"
	WritablePowerPortTemplateTypeNemaL520p string = "nema-l5-20p"

	// WritablePowerPortTemplateTypeNemaL530p captures enum value "nema-l5-30p"
	WritablePowerPortTemplateTypeNemaL530p string = "nema-l5-30p"

	// WritablePowerPortTemplateTypeNemaL550p captures enum value "nema-l5-50p"
	WritablePowerPortTemplateTypeNemaL550p string = "nema-l5-50p"

	// WritablePowerPortTemplateTypeNemaL620p captures enum value "nema-l6-20p"
	WritablePowerPortTemplateTypeNemaL620p string = "nema-l6-20p"

	// WritablePowerPortTemplateTypeNemaL630p captures enum value "nema-l6-30p"
	WritablePowerPortTemplateTypeNemaL630p string = "nema-l6-30p"

	// WritablePowerPortTemplateTypeNemaL650p captures enum value "nema-l6-50p"
	WritablePowerPortTemplateTypeNemaL650p string = "nema-l6-50p"

	// WritablePowerPortTemplateTypeCs6361c captures enum value "cs6361c"
	WritablePowerPortTemplateTypeCs6361c string = "cs6361c"

	// WritablePowerPortTemplateTypeCs6365c captures enum value "cs6365c"
	WritablePowerPortTemplateTypeCs6365c string = "cs6365c"

	// WritablePowerPortTemplateTypeCs8165c captures enum value "cs8165c"
	WritablePowerPortTemplateTypeCs8165c string = "cs8165c"

	// WritablePowerPortTemplateTypeCs8265c captures enum value "cs8265c"
	WritablePowerPortTemplateTypeCs8265c string = "cs8265c"

	// WritablePowerPortTemplateTypeCs8365c captures enum value "cs8365c"
	WritablePowerPortTemplateTypeCs8365c string = "cs8365c"

	// WritablePowerPortTemplateTypeCs8465c captures enum value "cs8465c"
	WritablePowerPortTemplateTypeCs8465c string = "cs8465c"

	// WritablePowerPortTemplateTypeItae captures enum value "ita-e"
	WritablePowerPortTemplateTypeItae string = "ita-e"

	// WritablePowerPortTemplateTypeItaf captures enum value "ita-f"
	WritablePowerPortTemplateTypeItaf string = "ita-f"

	// WritablePowerPortTemplateTypeItaEf captures enum value "ita-ef"
	WritablePowerPortTemplateTypeItaEf string = "ita-ef"

	// WritablePowerPortTemplateTypeItag captures enum value "ita-g"
	WritablePowerPortTemplateTypeItag string = "ita-g"

	// WritablePowerPortTemplateTypeItah captures enum value "ita-h"
	WritablePowerPortTemplateTypeItah string = "ita-h"

	// WritablePowerPortTemplateTypeItai captures enum value "ita-i"
	WritablePowerPortTemplateTypeItai string = "ita-i"

	// WritablePowerPortTemplateTypeItaj captures enum value "ita-j"
	WritablePowerPortTemplateTypeItaj string = "ita-j"

	// WritablePowerPortTemplateTypeItak captures enum value "ita-k"
	WritablePowerPortTemplateTypeItak string = "ita-k"

	// WritablePowerPortTemplateTypeItal captures enum value "ita-l"
	WritablePowerPortTemplateTypeItal string = "ita-l"

	// WritablePowerPortTemplateTypeItam captures enum value "ita-m"
	WritablePowerPortTemplateTypeItam string = "ita-m"

	// WritablePowerPortTemplateTypeItan captures enum value "ita-n"
	WritablePowerPortTemplateTypeItan string = "ita-n"

	// WritablePowerPortTemplateTypeItao captures enum value "ita-o"
	WritablePowerPortTemplateTypeItao string = "ita-o"
)
View Source 
const (

	// WritablePrefixStatusContainer captures enum value "container"
	WritablePrefixStatusContainer string = "container"

	// WritablePrefixStatusActive captures enum value "active"
	WritablePrefixStatusActive string = "active"

	// WritablePrefixStatusReserved captures enum value "reserved"
	WritablePrefixStatusReserved string = "reserved"

	// WritablePrefixStatusDeprecated captures enum value "deprecated"
	WritablePrefixStatusDeprecated string = "deprecated"
)
View Source 
const (

	// WritableRackOuterUnitMm captures enum value "mm"
	WritableRackOuterUnitMm string = "mm"

	// WritableRackOuterUnitIn captures enum value "in"
	WritableRackOuterUnitIn string = "in"
)
View Source 
const (

	// WritableRackStatusReserved captures enum value "reserved"
	WritableRackStatusReserved string = "reserved"

	// WritableRackStatusAvailable captures enum value "available"
	WritableRackStatusAvailable string = "available"

	// WritableRackStatusPlanned captures enum value "planned"
	WritableRackStatusPlanned string = "planned"

	// WritableRackStatusActive captures enum value "active"
	WritableRackStatusActive string = "active"

	// WritableRackStatusDeprecated captures enum value "deprecated"
	WritableRackStatusDeprecated string = "deprecated"
)
View Source 
const (

	// WritableRackTypeNr2PostFrame captures enum value "2-post-frame"
	WritableRackTypeNr2PostFrame string = "2-post-frame"

	// WritableRackTypeNr4PostFrame captures enum value "4-post-frame"
	WritableRackTypeNr4PostFrame string = "4-post-frame"

	// WritableRackTypeNr4PostCabinet captures enum value "4-post-cabinet"
	WritableRackTypeNr4PostCabinet string = "4-post-cabinet"

	// WritableRackTypeWallFrame captures enum value "wall-frame"
	WritableRackTypeWallFrame string = "wall-frame"

	// WritableRackTypeWallCabinet captures enum value "wall-cabinet"
	WritableRackTypeWallCabinet string = "wall-cabinet"
)
View Source 
const (

	// WritableRearPortTypeNr8p8c captures enum value "8p8c"
	WritableRearPortTypeNr8p8c string = "8p8c"

	// WritableRearPortTypeNr110Punch captures enum value "110-punch"
	WritableRearPortTypeNr110Punch string = "110-punch"

	// WritableRearPortTypeBnc captures enum value "bnc"
	WritableRearPortTypeBnc string = "bnc"

	// WritableRearPortTypeFc captures enum value "fc"
	WritableRearPortTypeFc string = "fc"

	// WritableRearPortTypeLc captures enum value "lc"
	WritableRearPortTypeLc string = "lc"

	// WritableRearPortTypeLcApc captures enum value "lc-apc"
	WritableRearPortTypeLcApc string = "lc-apc"

	// WritableRearPortTypeLsh captures enum value "lsh"
	WritableRearPortTypeLsh string = "lsh"

	// WritableRearPortTypeLshApc captures enum value "lsh-apc"
	WritableRearPortTypeLshApc string = "lsh-apc"

	// WritableRearPortTypeMpo captures enum value "mpo"
	WritableRearPortTypeMpo string = "mpo"

	// WritableRearPortTypeMtrj captures enum value "mtrj"
	WritableRearPortTypeMtrj string = "mtrj"

	// WritableRearPortTypeSc captures enum value "sc"
	WritableRearPortTypeSc string = "sc"

	// WritableRearPortTypeScApc captures enum value "sc-apc"
	WritableRearPortTypeScApc string = "sc-apc"

	// WritableRearPortTypeSt captures enum value "st"
	WritableRearPortTypeSt string = "st"
)
View Source 
const (

	// WritableRearPortTemplateTypeNr8p8c captures enum value "8p8c"
	WritableRearPortTemplateTypeNr8p8c string = "8p8c"

	// WritableRearPortTemplateTypeNr110Punch captures enum value "110-punch"
	WritableRearPortTemplateTypeNr110Punch string = "110-punch"

	// WritableRearPortTemplateTypeBnc captures enum value "bnc"
	WritableRearPortTemplateTypeBnc string = "bnc"

	// WritableRearPortTemplateTypeFc captures enum value "fc"
	WritableRearPortTemplateTypeFc string = "fc"

	// WritableRearPortTemplateTypeLc captures enum value "lc"
	WritableRearPortTemplateTypeLc string = "lc"

	// WritableRearPortTemplateTypeLcApc captures enum value "lc-apc"
	WritableRearPortTemplateTypeLcApc string = "lc-apc"

	// WritableRearPortTemplateTypeLsh captures enum value "lsh"
	WritableRearPortTemplateTypeLsh string = "lsh"

	// WritableRearPortTemplateTypeLshApc captures enum value "lsh-apc"
	WritableRearPortTemplateTypeLshApc string = "lsh-apc"

	// WritableRearPortTemplateTypeMpo captures enum value "mpo"
	WritableRearPortTemplateTypeMpo string = "mpo"

	// WritableRearPortTemplateTypeMtrj captures enum value "mtrj"
	WritableRearPortTemplateTypeMtrj string = "mtrj"

	// WritableRearPortTemplateTypeSc captures enum value "sc"
	WritableRearPortTemplateTypeSc string = "sc"

	// WritableRearPortTemplateTypeScApc captures enum value "sc-apc"
	WritableRearPortTemplateTypeScApc string = "sc-apc"

	// WritableRearPortTemplateTypeSt captures enum value "st"
	WritableRearPortTemplateTypeSt string = "st"
)
View Source 
const (

	// WritableServiceProtocolTCP captures enum value "tcp"
	WritableServiceProtocolTCP string = "tcp"

	// WritableServiceProtocolUDP captures enum value "udp"
	WritableServiceProtocolUDP string = "udp"
)
View Source 
const (

	// WritableSiteStatusActive captures enum value "active"
	WritableSiteStatusActive string = "active"

	// WritableSiteStatusPlanned captures enum value "planned"
	WritableSiteStatusPlanned string = "planned"

	// WritableSiteStatusRetired captures enum value "retired"
	WritableSiteStatusRetired string = "retired"
)
View Source 
const (

	// WritableVLANStatusActive captures enum value "active"
	WritableVLANStatusActive string = "active"

	// WritableVLANStatusReserved captures enum value "reserved"
	WritableVLANStatusReserved string = "reserved"

	// WritableVLANStatusDeprecated captures enum value "deprecated"
	WritableVLANStatusDeprecated string = "deprecated"
)
View Source 
const (

	// WritableVirtualMachineInterfaceModeAccess captures enum value "access"
	WritableVirtualMachineInterfaceModeAccess string = "access"

	// WritableVirtualMachineInterfaceModeTagged captures enum value "tagged"
	WritableVirtualMachineInterfaceModeTagged string = "tagged"

	// WritableVirtualMachineInterfaceModeTaggedAll captures enum value "tagged-all"
	WritableVirtualMachineInterfaceModeTaggedAll string = "tagged-all"
)
View Source 
const (

	// WritableVirtualMachineInterfaceTypeVirtual captures enum value "virtual"
	WritableVirtualMachineInterfaceTypeVirtual string = "virtual"

	// WritableVirtualMachineInterfaceTypeLag captures enum value "lag"
	WritableVirtualMachineInterfaceTypeLag string = "lag"

	// WritableVirtualMachineInterfaceTypeNr100baseTx captures enum value "100base-tx"
	WritableVirtualMachineInterfaceTypeNr100baseTx string = "100base-tx"

	// WritableVirtualMachineInterfaceTypeNr1000baset captures enum value "1000base-t"
	WritableVirtualMachineInterfaceTypeNr1000baset string = "1000base-t"

	// WritableVirtualMachineInterfaceTypeNr25gbaset captures enum value "2.5gbase-t"
	WritableVirtualMachineInterfaceTypeNr25gbaset string = "2.5gbase-t"

	// WritableVirtualMachineInterfaceTypeNr5gbaset captures enum value "5gbase-t"
	WritableVirtualMachineInterfaceTypeNr5gbaset string = "5gbase-t"

	// WritableVirtualMachineInterfaceTypeNr10gbaset captures enum value "10gbase-t"
	WritableVirtualMachineInterfaceTypeNr10gbaset string = "10gbase-t"

	// WritableVirtualMachineInterfaceTypeNr10gbaseCx4 captures enum value "10gbase-cx4"
	WritableVirtualMachineInterfaceTypeNr10gbaseCx4 string = "10gbase-cx4"

	// WritableVirtualMachineInterfaceTypeNr1000basexGbic captures enum value "1000base-x-gbic"
	WritableVirtualMachineInterfaceTypeNr1000basexGbic string = "1000base-x-gbic"

	// WritableVirtualMachineInterfaceTypeNr1000basexSfp captures enum value "1000base-x-sfp"
	WritableVirtualMachineInterfaceTypeNr1000basexSfp string = "1000base-x-sfp"

	// WritableVirtualMachineInterfaceTypeNr10gbasexSfpp captures enum value "10gbase-x-sfpp"
	WritableVirtualMachineInterfaceTypeNr10gbasexSfpp string = "10gbase-x-sfpp"

	// WritableVirtualMachineInterfaceTypeNr10gbasexXfp captures enum value "10gbase-x-xfp"
	WritableVirtualMachineInterfaceTypeNr10gbasexXfp string = "10gbase-x-xfp"

	// WritableVirtualMachineInterfaceTypeNr10gbasexXenpak captures enum value "10gbase-x-xenpak"
	WritableVirtualMachineInterfaceTypeNr10gbasexXenpak string = "10gbase-x-xenpak"

	// WritableVirtualMachineInterfaceTypeNr10gbasexX2 captures enum value "10gbase-x-x2"
	WritableVirtualMachineInterfaceTypeNr10gbasexX2 string = "10gbase-x-x2"

	// WritableVirtualMachineInterfaceTypeNr25gbasexSfp28 captures enum value "25gbase-x-sfp28"
	WritableVirtualMachineInterfaceTypeNr25gbasexSfp28 string = "25gbase-x-sfp28"

	// WritableVirtualMachineInterfaceTypeNr40gbasexQsfpp captures enum value "40gbase-x-qsfpp"
	WritableVirtualMachineInterfaceTypeNr40gbasexQsfpp string = "40gbase-x-qsfpp"

	// WritableVirtualMachineInterfaceTypeNr50gbasexSfp28 captures enum value "50gbase-x-sfp28"
	WritableVirtualMachineInterfaceTypeNr50gbasexSfp28 string = "50gbase-x-sfp28"

	// WritableVirtualMachineInterfaceTypeNr100gbasexCfp captures enum value "100gbase-x-cfp"
	WritableVirtualMachineInterfaceTypeNr100gbasexCfp string = "100gbase-x-cfp"

	// WritableVirtualMachineInterfaceTypeNr100gbasexCfp2 captures enum value "100gbase-x-cfp2"
	WritableVirtualMachineInterfaceTypeNr100gbasexCfp2 string = "100gbase-x-cfp2"

	// WritableVirtualMachineInterfaceTypeNr200gbasexCfp2 captures enum value "200gbase-x-cfp2"
	WritableVirtualMachineInterfaceTypeNr200gbasexCfp2 string = "200gbase-x-cfp2"

	// WritableVirtualMachineInterfaceTypeNr100gbasexCfp4 captures enum value "100gbase-x-cfp4"
	WritableVirtualMachineInterfaceTypeNr100gbasexCfp4 string = "100gbase-x-cfp4"

	// WritableVirtualMachineInterfaceTypeNr100gbasexCpak captures enum value "100gbase-x-cpak"
	WritableVirtualMachineInterfaceTypeNr100gbasexCpak string = "100gbase-x-cpak"

	// WritableVirtualMachineInterfaceTypeNr100gbasexQsfp28 captures enum value "100gbase-x-qsfp28"
	WritableVirtualMachineInterfaceTypeNr100gbasexQsfp28 string = "100gbase-x-qsfp28"

	// WritableVirtualMachineInterfaceTypeNr200gbasexQsfp56 captures enum value "200gbase-x-qsfp56"
	WritableVirtualMachineInterfaceTypeNr200gbasexQsfp56 string = "200gbase-x-qsfp56"

	// WritableVirtualMachineInterfaceTypeNr400gbasexQsfpdd captures enum value "400gbase-x-qsfpdd"
	WritableVirtualMachineInterfaceTypeNr400gbasexQsfpdd string = "400gbase-x-qsfpdd"

	// WritableVirtualMachineInterfaceTypeNr400gbasexOsfp captures enum value "400gbase-x-osfp"
	WritableVirtualMachineInterfaceTypeNr400gbasexOsfp string = "400gbase-x-osfp"

	// WritableVirtualMachineInterfaceTypeIeee80211a captures enum value "ieee802.11a"
	WritableVirtualMachineInterfaceTypeIeee80211a string = "ieee802.11a"

	// WritableVirtualMachineInterfaceTypeIeee80211g captures enum value "ieee802.11g"
	WritableVirtualMachineInterfaceTypeIeee80211g string = "ieee802.11g"

	// WritableVirtualMachineInterfaceTypeIeee80211n captures enum value "ieee802.11n"
	WritableVirtualMachineInterfaceTypeIeee80211n string = "ieee802.11n"

	// WritableVirtualMachineInterfaceTypeIeee80211ac captures enum value "ieee802.11ac"
	WritableVirtualMachineInterfaceTypeIeee80211ac string = "ieee802.11ac"

	// WritableVirtualMachineInterfaceTypeIeee80211ad captures enum value "ieee802.11ad"
	WritableVirtualMachineInterfaceTypeIeee80211ad string = "ieee802.11ad"

	// WritableVirtualMachineInterfaceTypeIeee80211ax captures enum value "ieee802.11ax"
	WritableVirtualMachineInterfaceTypeIeee80211ax string = "ieee802.11ax"

	// WritableVirtualMachineInterfaceTypeGsm captures enum value "gsm"
	WritableVirtualMachineInterfaceTypeGsm string = "gsm"

	// WritableVirtualMachineInterfaceTypeCdma captures enum value "cdma"
	WritableVirtualMachineInterfaceTypeCdma string = "cdma"

	// WritableVirtualMachineInterfaceTypeLte captures enum value "lte"
	WritableVirtualMachineInterfaceTypeLte string = "lte"

	// WritableVirtualMachineInterfaceTypeSonetOc3 captures enum value "sonet-oc3"
	WritableVirtualMachineInterfaceTypeSonetOc3 string = "sonet-oc3"

	// WritableVirtualMachineInterfaceTypeSonetOc12 captures enum value "sonet-oc12"
	WritableVirtualMachineInterfaceTypeSonetOc12 string = "sonet-oc12"

	// WritableVirtualMachineInterfaceTypeSonetOc48 captures enum value "sonet-oc48"
	WritableVirtualMachineInterfaceTypeSonetOc48 string = "sonet-oc48"

	// WritableVirtualMachineInterfaceTypeSonetOc192 captures enum value "sonet-oc192"
	WritableVirtualMachineInterfaceTypeSonetOc192 string = "sonet-oc192"

	// WritableVirtualMachineInterfaceTypeSonetOc768 captures enum value "sonet-oc768"
	WritableVirtualMachineInterfaceTypeSonetOc768 string = "sonet-oc768"

	// WritableVirtualMachineInterfaceTypeSonetOc1920 captures enum value "sonet-oc1920"
	WritableVirtualMachineInterfaceTypeSonetOc1920 string = "sonet-oc1920"

	// WritableVirtualMachineInterfaceTypeSonetOc3840 captures enum value "sonet-oc3840"
	WritableVirtualMachineInterfaceTypeSonetOc3840 string = "sonet-oc3840"

	// WritableVirtualMachineInterfaceTypeNr1gfcSfp captures enum value "1gfc-sfp"
	WritableVirtualMachineInterfaceTypeNr1gfcSfp string = "1gfc-sfp"

	// WritableVirtualMachineInterfaceTypeNr2gfcSfp captures enum value "2gfc-sfp"
	WritableVirtualMachineInterfaceTypeNr2gfcSfp string = "2gfc-sfp"

	// WritableVirtualMachineInterfaceTypeNr4gfcSfp captures enum value "4gfc-sfp"
	WritableVirtualMachineInterfaceTypeNr4gfcSfp string = "4gfc-sfp"

	// WritableVirtualMachineInterfaceTypeNr8gfcSfpp captures enum value "8gfc-sfpp"
	WritableVirtualMachineInterfaceTypeNr8gfcSfpp string = "8gfc-sfpp"

	// WritableVirtualMachineInterfaceTypeNr16gfcSfpp captures enum value "16gfc-sfpp"
	WritableVirtualMachineInterfaceTypeNr16gfcSfpp string = "16gfc-sfpp"

	// WritableVirtualMachineInterfaceTypeNr32gfcSfp28 captures enum value "32gfc-sfp28"
	WritableVirtualMachineInterfaceTypeNr32gfcSfp28 string = "32gfc-sfp28"

	// WritableVirtualMachineInterfaceTypeNr128gfcSfp28 captures enum value "128gfc-sfp28"
	WritableVirtualMachineInterfaceTypeNr128gfcSfp28 string = "128gfc-sfp28"

	// WritableVirtualMachineInterfaceTypeInifibandSdr captures enum value "inifiband-sdr"
	WritableVirtualMachineInterfaceTypeInifibandSdr string = "inifiband-sdr"

	// WritableVirtualMachineInterfaceTypeInifibandDdr captures enum value "inifiband-ddr"
	WritableVirtualMachineInterfaceTypeInifibandDdr string = "inifiband-ddr"

	// WritableVirtualMachineInterfaceTypeInifibandQdr captures enum value "inifiband-qdr"
	WritableVirtualMachineInterfaceTypeInifibandQdr string = "inifiband-qdr"

	// WritableVirtualMachineInterfaceTypeInifibandFdr10 captures enum value "inifiband-fdr10"
	WritableVirtualMachineInterfaceTypeInifibandFdr10 string = "inifiband-fdr10"

	// WritableVirtualMachineInterfaceTypeInifibandFdr captures enum value "inifiband-fdr"
	WritableVirtualMachineInterfaceTypeInifibandFdr string = "inifiband-fdr"

	// WritableVirtualMachineInterfaceTypeInifibandEdr captures enum value "inifiband-edr"
	WritableVirtualMachineInterfaceTypeInifibandEdr string = "inifiband-edr"

	// WritableVirtualMachineInterfaceTypeInifibandHdr captures enum value "inifiband-hdr"
	WritableVirtualMachineInterfaceTypeInifibandHdr string = "inifiband-hdr"

	// WritableVirtualMachineInterfaceTypeInifibandNdr captures enum value "inifiband-ndr"
	WritableVirtualMachineInterfaceTypeInifibandNdr string = "inifiband-ndr"

	// WritableVirtualMachineInterfaceTypeInifibandXdr captures enum value "inifiband-xdr"
	WritableVirtualMachineInterfaceTypeInifibandXdr string = "inifiband-xdr"

	// WritableVirtualMachineInterfaceTypeT1 captures enum value "t1"
	WritableVirtualMachineInterfaceTypeT1 string = "t1"

	// WritableVirtualMachineInterfaceTypeE1 captures enum value "e1"
	WritableVirtualMachineInterfaceTypeE1 string = "e1"

	// WritableVirtualMachineInterfaceTypeT3 captures enum value "t3"
	WritableVirtualMachineInterfaceTypeT3 string = "t3"

	// WritableVirtualMachineInterfaceTypeE3 captures enum value "e3"
	WritableVirtualMachineInterfaceTypeE3 string = "e3"

	// WritableVirtualMachineInterfaceTypeCiscoStackwise captures enum value "cisco-stackwise"
	WritableVirtualMachineInterfaceTypeCiscoStackwise string = "cisco-stackwise"

	// WritableVirtualMachineInterfaceTypeCiscoStackwisePlus captures enum value "cisco-stackwise-plus"
	WritableVirtualMachineInterfaceTypeCiscoStackwisePlus string = "cisco-stackwise-plus"

	// WritableVirtualMachineInterfaceTypeCiscoFlexstack captures enum value "cisco-flexstack"
	WritableVirtualMachineInterfaceTypeCiscoFlexstack string = "cisco-flexstack"

	// WritableVirtualMachineInterfaceTypeCiscoFlexstackPlus captures enum value "cisco-flexstack-plus"
	WritableVirtualMachineInterfaceTypeCiscoFlexstackPlus string = "cisco-flexstack-plus"

	// WritableVirtualMachineInterfaceTypeJuniperVcp captures enum value "juniper-vcp"
	WritableVirtualMachineInterfaceTypeJuniperVcp string = "juniper-vcp"

	// WritableVirtualMachineInterfaceTypeExtremeSummitstack captures enum value "extreme-summitstack"
	WritableVirtualMachineInterfaceTypeExtremeSummitstack string = "extreme-summitstack"

	// WritableVirtualMachineInterfaceTypeExtremeSummitstack128 captures enum value "extreme-summitstack-128"
	WritableVirtualMachineInterfaceTypeExtremeSummitstack128 string = "extreme-summitstack-128"

	// WritableVirtualMachineInterfaceTypeExtremeSummitstack256 captures enum value "extreme-summitstack-256"
	WritableVirtualMachineInterfaceTypeExtremeSummitstack256 string = "extreme-summitstack-256"

	// WritableVirtualMachineInterfaceTypeExtremeSummitstack512 captures enum value "extreme-summitstack-512"
	WritableVirtualMachineInterfaceTypeExtremeSummitstack512 string = "extreme-summitstack-512"

	// WritableVirtualMachineInterfaceTypeOther captures enum value "other"
	WritableVirtualMachineInterfaceTypeOther string = "other"
)
View Source 
const (

	// WritableVirtualMachineWithConfigContextStatusOffline captures enum value "offline"
	WritableVirtualMachineWithConfigContextStatusOffline string = "offline"

	// WritableVirtualMachineWithConfigContextStatusActive captures enum value "active"
	WritableVirtualMachineWithConfigContextStatusActive string = "active"

	// WritableVirtualMachineWithConfigContextStatusPlanned captures enum value "planned"
	WritableVirtualMachineWithConfigContextStatusPlanned string = "planned"

	// WritableVirtualMachineWithConfigContextStatusStaged captures enum value "staged"
	WritableVirtualMachineWithConfigContextStatusStaged string = "staged"

	// WritableVirtualMachineWithConfigContextStatusFailed captures enum value "failed"
	WritableVirtualMachineWithConfigContextStatusFailed string = "failed"

	// WritableVirtualMachineWithConfigContextStatusDecommissioning captures enum value "decommissioning"
	WritableVirtualMachineWithConfigContextStatusDecommissioning string = "decommissioning"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Aggregate 

type Aggregate struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Date added
	// Format: date
	DateAdded *strfmt.Date `json:"date_added,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// family
	Family *AggregateFamily `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Prefix
	// Required: true
	Prefix *string `json:"prefix"`

	// rir
	// Required: true
	Rir *NestedRIR `json:"rir"`

	// tags
	Tags []string `json:"tags"`
}

Aggregate aggregate swagger:model Aggregate

func (*Aggregate) MarshalBinary 

func (m *Aggregate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Aggregate) UnmarshalBinary 

func (m *Aggregate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Aggregate) Validate 

func (m *Aggregate) Validate(formats strfmt.Registry) error

Validate validates this aggregate

type AggregateFamily 

type AggregateFamily struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

AggregateFamily Family swagger:model AggregateFamily

func (*AggregateFamily) MarshalBinary 

func (m *AggregateFamily) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AggregateFamily) UnmarshalBinary 

func (m *AggregateFamily) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AggregateFamily) Validate 

func (m *AggregateFamily) Validate(formats strfmt.Registry) error

Validate validates this aggregate family

type AvailableIPAddress 

type AvailableIPAddress struct {
	Address *string    `json:"address"`
	Family  int64      `json:"family"`
	Vrf     *NestedVRF `json:"vrf:omitempty"`
}

func (*AvailableIPAddress) MarshalBinary 

func (m *AvailableIPAddress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*AvailableIPAddress) UnmarshalBinary 

func (m *AvailableIPAddress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*AvailableIPAddress) Validate 

func (m *AvailableIPAddress) Validate(formats strfmt.Registry) error

Validate validates this IP address

type Cable 

type Cable struct {

	// Color
	// Max Length: 6
	// Pattern: ^[0-9a-f]{6}$
	Color string `json:"color,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Label
	// Max Length: 100
	Label string `json:"label,omitempty"`

	// Length
	// Maximum: 32767
	// Minimum: 0
	Length *int64 `json:"length,omitempty"`

	// length unit
	LengthUnit *CableLengthUnit `json:"length_unit,omitempty"`

	// status
	Status *CableStatus `json:"status,omitempty"`

	// Termination a
	// Read Only: true
	Terminationa map[string]string `json:"termination_a,omitempty"`

	// Termination a id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	TerminationaID *int64 `json:"termination_a_id"`

	// Termination a type
	// Required: true
	TerminationaType *string `json:"termination_a_type"`

	// Termination b
	// Read Only: true
	Terminationb map[string]string `json:"termination_b,omitempty"`

	// Termination b id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	TerminationbID *int64 `json:"termination_b_id"`

	// Termination b type
	// Required: true
	TerminationbType *string `json:"termination_b_type"`

	// Type
	// Enum: [cat3 cat5 cat5e cat6 cat6a cat7 dac-active dac-passive coaxial mmf mmf-om1 mmf-om2 mmf-om3 mmf-om4 smf smf-os1 smf-os2 aoc power]
	Type string `json:"type,omitempty"`
}

Cable cable swagger:model Cable

func (*Cable) MarshalBinary 

func (m *Cable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Cable) UnmarshalBinary 

func (m *Cable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cable) Validate 

func (m *Cable) Validate(formats strfmt.Registry) error

Validate validates this cable

type CableLengthUnit 

type CableLengthUnit struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

CableLengthUnit Length unit swagger:model CableLengthUnit

func (*CableLengthUnit) MarshalBinary 

func (m *CableLengthUnit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CableLengthUnit) UnmarshalBinary 

func (m *CableLengthUnit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CableLengthUnit) Validate 

func (m *CableLengthUnit) Validate(formats strfmt.Registry) error

Validate validates this cable length unit

type CableStatus 

type CableStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

CableStatus Status swagger:model CableStatus

func (*CableStatus) MarshalBinary 

func (m *CableStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CableStatus) UnmarshalBinary 

func (m *CableStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CableStatus) Validate 

func (m *CableStatus) Validate(formats strfmt.Registry) error

Validate validates this cable status

type Circuit 

type Circuit struct {

	// Circuit ID
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Cid *string `json:"cid"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Commit rate (Kbps)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	CommitRate *int64 `json:"commit_rate,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Date installed
	// Format: date
	InstallDate *strfmt.Date `json:"install_date,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// provider
	// Required: true
	Provider *NestedProvider `json:"provider"`

	// status
	Status *CircuitStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// termination a
	Terminationa *CircuitCircuitTermination `json:"termination_a,omitempty"`

	// termination z
	Terminationz *CircuitCircuitTermination `json:"termination_z,omitempty"`

	// type
	// Required: true
	Type *NestedCircuitType `json:"type"`
}

Circuit circuit swagger:model Circuit

func (*Circuit) MarshalBinary 

func (m *Circuit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Circuit) UnmarshalBinary 

func (m *Circuit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Circuit) Validate 

func (m *Circuit) Validate(formats strfmt.Registry) error

Validate validates this circuit

type CircuitCircuitTermination 

type CircuitCircuitTermination struct {

	// connected endpoint
	// Required: true
	ConnectedEndpoint *NestedInterface `json:"connected_endpoint"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Port speed (Kbps)
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	PortSpeed *int64 `json:"port_speed"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// Upstream speed (Kbps)
	//
	// Upstream speed, if different from port speed
	// Maximum: 2.147483647e+09
	// Minimum: 0
	UpstreamSpeed *int64 `json:"upstream_speed,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Cross-connect ID
	// Max Length: 50
	XconnectID string `json:"xconnect_id,omitempty"`
}

CircuitCircuitTermination Termination a swagger:model CircuitCircuitTermination

func (*CircuitCircuitTermination) MarshalBinary 

func (m *CircuitCircuitTermination) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CircuitCircuitTermination) UnmarshalBinary 

func (m *CircuitCircuitTermination) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CircuitCircuitTermination) Validate 

func (m *CircuitCircuitTermination) Validate(formats strfmt.Registry) error

Validate validates this circuit circuit termination

type CircuitStatus 

type CircuitStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

CircuitStatus Status swagger:model CircuitStatus

func (*CircuitStatus) MarshalBinary 

func (m *CircuitStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CircuitStatus) UnmarshalBinary 

func (m *CircuitStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CircuitStatus) Validate 

func (m *CircuitStatus) Validate(formats strfmt.Registry) error

Validate validates this circuit status

type CircuitTermination 

type CircuitTermination struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// circuit
	// Required: true
	Circuit *NestedCircuit `json:"circuit"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *CircuitTerminationConnectionStatus `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Port speed (Kbps)
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	PortSpeed *int64 `json:"port_speed"`

	// Patch panel/port(s)
	// Max Length: 100
	PpInfo string `json:"pp_info,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// Termination
	// Required: true
	// Enum: [A Z]
	TermSide *string `json:"term_side"`

	// Upstream speed (Kbps)
	//
	// Upstream speed, if different from port speed
	// Maximum: 2.147483647e+09
	// Minimum: 0
	UpstreamSpeed *int64 `json:"upstream_speed,omitempty"`

	// Cross-connect ID
	// Max Length: 50
	XconnectID string `json:"xconnect_id,omitempty"`
}

CircuitTermination circuit termination swagger:model CircuitTermination

func (*CircuitTermination) MarshalBinary 

func (m *CircuitTermination) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CircuitTermination) UnmarshalBinary 

func (m *CircuitTermination) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CircuitTermination) Validate 

func (m *CircuitTermination) Validate(formats strfmt.Registry) error

Validate validates this circuit termination

type CircuitTerminationConnectionStatus 

type CircuitTerminationConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

CircuitTerminationConnectionStatus Connection status swagger:model CircuitTerminationConnectionStatus

func (*CircuitTerminationConnectionStatus) MarshalBinary 

func (m *CircuitTerminationConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CircuitTerminationConnectionStatus) UnmarshalBinary 

func (m *CircuitTerminationConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CircuitTerminationConnectionStatus) Validate 

func (m *CircuitTerminationConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this circuit termination connection status

type CircuitType 

type CircuitType struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

CircuitType circuit type swagger:model CircuitType

func (*CircuitType) MarshalBinary 

func (m *CircuitType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*CircuitType) UnmarshalBinary 

func (m *CircuitType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*CircuitType) Validate 

func (m *CircuitType) Validate(formats strfmt.Registry) error

Validate validates this circuit type

type Cluster 

type Cluster struct {

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// group
	Group *NestedClusterGroup `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// site
	Site *NestedSite `json:"site,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// type
	// Required: true
	Type *NestedClusterType `json:"type"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

Cluster cluster swagger:model Cluster

func (*Cluster) MarshalBinary 

func (m *Cluster) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Cluster) UnmarshalBinary 

func (m *Cluster) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Cluster) Validate 

func (m *Cluster) Validate(formats strfmt.Registry) error

Validate validates this cluster

type ClusterGroup 

type ClusterGroup struct {

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

ClusterGroup cluster group swagger:model ClusterGroup

func (*ClusterGroup) MarshalBinary 

func (m *ClusterGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterGroup) UnmarshalBinary 

func (m *ClusterGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterGroup) Validate 

func (m *ClusterGroup) Validate(formats strfmt.Registry) error

Validate validates this cluster group

type ClusterType 

type ClusterType struct {

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

ClusterType cluster type swagger:model ClusterType

func (*ClusterType) MarshalBinary 

func (m *ClusterType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ClusterType) UnmarshalBinary 

func (m *ClusterType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ClusterType) Validate 

func (m *ClusterType) Validate(formats strfmt.Registry) error

Validate validates this cluster type

type ConfigContext 

type ConfigContext struct {

	// cluster groups
	// Unique: true
	ClusterGroups []*NestedClusterGroup `json:"cluster_groups"`

	// clusters
	// Unique: true
	Clusters []*NestedCluster `json:"clusters"`

	// Data
	// Required: true
	Data *string `json:"data"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is active
	IsActive bool `json:"is_active,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// platforms
	// Unique: true
	Platforms []*NestedPlatform `json:"platforms"`

	// regions
	// Unique: true
	Regions []*NestedRegion `json:"regions"`

	// roles
	// Unique: true
	Roles []*NestedDeviceRole `json:"roles"`

	// sites
	// Unique: true
	Sites []*NestedSite `json:"sites"`

	// tags
	// Unique: true
	Tags []string `json:"tags"`

	// tenant groups
	// Unique: true
	TenantGroups []*NestedTenantGroup `json:"tenant_groups"`

	// tenants
	// Unique: true
	Tenants []*NestedTenant `json:"tenants"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

ConfigContext config context swagger:model ConfigContext

func (*ConfigContext) MarshalBinary 

func (m *ConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConfigContext) UnmarshalBinary 

func (m *ConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConfigContext) Validate 

func (m *ConfigContext) Validate(formats strfmt.Registry) error

Validate validates this config context

type ConsolePort 

type ConsolePort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *ConsolePortConnectionStatus `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *ConsolePortType `json:"type,omitempty"`
}

ConsolePort console port swagger:model ConsolePort

func (*ConsolePort) MarshalBinary 

func (m *ConsolePort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsolePort) UnmarshalBinary 

func (m *ConsolePort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsolePort) Validate 

func (m *ConsolePort) Validate(formats strfmt.Registry) error

Validate validates this console port

type ConsolePortConnectionStatus 

type ConsolePortConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

ConsolePortConnectionStatus Connection status swagger:model ConsolePortConnectionStatus

func (*ConsolePortConnectionStatus) MarshalBinary 

func (m *ConsolePortConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsolePortConnectionStatus) UnmarshalBinary 

func (m *ConsolePortConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsolePortConnectionStatus) Validate 

func (m *ConsolePortConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this console port connection status

type ConsolePortTemplate 

type ConsolePortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// type
	Type *ConsolePortTemplateType `json:"type,omitempty"`
}

ConsolePortTemplate console port template swagger:model ConsolePortTemplate

func (*ConsolePortTemplate) MarshalBinary 

func (m *ConsolePortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsolePortTemplate) UnmarshalBinary 

func (m *ConsolePortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsolePortTemplate) Validate 

func (m *ConsolePortTemplate) Validate(formats strfmt.Registry) error

Validate validates this console port template

type ConsolePortTemplateType 

type ConsolePortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ConsolePortTemplateType Type swagger:model ConsolePortTemplateType

func (*ConsolePortTemplateType) MarshalBinary 

func (m *ConsolePortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsolePortTemplateType) UnmarshalBinary 

func (m *ConsolePortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsolePortTemplateType) Validate 

func (m *ConsolePortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this console port template type

type ConsolePortType 

type ConsolePortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ConsolePortType Type swagger:model ConsolePortType

func (*ConsolePortType) MarshalBinary 

func (m *ConsolePortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsolePortType) UnmarshalBinary 

func (m *ConsolePortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsolePortType) Validate 

func (m *ConsolePortType) Validate(formats strfmt.Registry) error

Validate validates this console port type

type ConsoleServerPort 

type ConsoleServerPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *ConsoleServerPortConnectionStatus `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *ConsoleServerPortType `json:"type,omitempty"`
}

ConsoleServerPort console server port swagger:model ConsoleServerPort

func (*ConsoleServerPort) MarshalBinary 

func (m *ConsoleServerPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsoleServerPort) UnmarshalBinary 

func (m *ConsoleServerPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsoleServerPort) Validate 

func (m *ConsoleServerPort) Validate(formats strfmt.Registry) error

Validate validates this console server port

type ConsoleServerPortConnectionStatus 

type ConsoleServerPortConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

ConsoleServerPortConnectionStatus Connection status swagger:model ConsoleServerPortConnectionStatus

func (*ConsoleServerPortConnectionStatus) MarshalBinary 

func (m *ConsoleServerPortConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsoleServerPortConnectionStatus) UnmarshalBinary 

func (m *ConsoleServerPortConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsoleServerPortConnectionStatus) Validate 

func (m *ConsoleServerPortConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this console server port connection status

type ConsoleServerPortTemplate 

type ConsoleServerPortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// type
	Type *ConsoleServerPortTemplateType `json:"type,omitempty"`
}

ConsoleServerPortTemplate console server port template swagger:model ConsoleServerPortTemplate

func (*ConsoleServerPortTemplate) MarshalBinary 

func (m *ConsoleServerPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsoleServerPortTemplate) UnmarshalBinary 

func (m *ConsoleServerPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsoleServerPortTemplate) Validate 

func (m *ConsoleServerPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this console server port template

type ConsoleServerPortTemplateType 

type ConsoleServerPortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ConsoleServerPortTemplateType Type swagger:model ConsoleServerPortTemplateType

func (*ConsoleServerPortTemplateType) MarshalBinary 

func (m *ConsoleServerPortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsoleServerPortTemplateType) UnmarshalBinary 

func (m *ConsoleServerPortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsoleServerPortTemplateType) Validate 

func (m *ConsoleServerPortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this console server port template type

type ConsoleServerPortType 

type ConsoleServerPortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ConsoleServerPortType Type swagger:model ConsoleServerPortType

func (*ConsoleServerPortType) MarshalBinary 

func (m *ConsoleServerPortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ConsoleServerPortType) UnmarshalBinary 

func (m *ConsoleServerPortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ConsoleServerPortType) Validate 

func (m *ConsoleServerPortType) Validate(formats strfmt.Registry) error

Validate validates this console server port type

type Device 

type Device struct {

	// Asset tag
	//
	// A unique tag used to identify this device
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// cluster
	Cluster *NestedCluster `json:"cluster,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// device role
	// Required: true
	DeviceRole *NestedDeviceRole `json:"device_role"`

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// face
	Face *DeviceFace `json:"face,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

	// parent device
	ParentDevice *NestedDevice `json:"parent_device,omitempty"`

	// platform
	Platform *NestedPlatform `json:"platform,omitempty"`

	// Position (U)
	//
	// The lowest-numbered unit occupied by the device
	// Maximum: 32767
	// Minimum: 1
	Position *int64 `json:"position,omitempty"`

	// primary ip
	PrimaryIP *NestedIPAddress `json:"primary_ip,omitempty"`

	// primary ip4
	PrimaryIp4 *NestedIPAddress `json:"primary_ip4,omitempty"`

	// primary ip6
	PrimaryIp6 *NestedIPAddress `json:"primary_ip6,omitempty"`

	// rack
	Rack *NestedRack `json:"rack,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// status
	Status *DeviceStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// Vc position
	// Maximum: 255
	// Minimum: 0
	VcPosition *int64 `json:"vc_position,omitempty"`

	// Vc priority
	// Maximum: 255
	// Minimum: 0
	VcPriority *int64 `json:"vc_priority,omitempty"`

	// virtual chassis
	VirtualChassis *NestedVirtualChassis `json:"virtual_chassis,omitempty"`
}

Device device swagger:model Device

func (*Device) MarshalBinary 

func (m *Device) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Device) UnmarshalBinary 

func (m *Device) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Device) Validate 

func (m *Device) Validate(formats strfmt.Registry) error

Validate validates this device

type DeviceBay 

type DeviceBay struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// installed device
	InstalledDevice *NestedDevice `json:"installed_device,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`
}

DeviceBay device bay swagger:model DeviceBay

func (*DeviceBay) MarshalBinary 

func (m *DeviceBay) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceBay) UnmarshalBinary 

func (m *DeviceBay) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceBay) Validate 

func (m *DeviceBay) Validate(formats strfmt.Registry) error

Validate validates this device bay

type DeviceBayTemplate 

type DeviceBayTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`
}

DeviceBayTemplate device bay template swagger:model DeviceBayTemplate

func (*DeviceBayTemplate) MarshalBinary 

func (m *DeviceBayTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceBayTemplate) UnmarshalBinary 

func (m *DeviceBayTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceBayTemplate) Validate 

func (m *DeviceBayTemplate) Validate(formats strfmt.Registry) error

Validate validates this device bay template

type DeviceFace 

type DeviceFace struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceFace Face swagger:model DeviceFace

func (*DeviceFace) MarshalBinary 

func (m *DeviceFace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceFace) UnmarshalBinary 

func (m *DeviceFace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceFace) Validate 

func (m *DeviceFace) Validate(formats strfmt.Registry) error

Validate validates this device face

type DeviceInterface 

type DeviceInterface struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *DeviceInterfaceConnectionStatus `json:"connection_status,omitempty"`

	// Count ipaddresses
	// Read Only: true
	CountIpaddresses string `json:"count_ipaddresses,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Enabled
	Enabled bool `json:"enabled,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// lag
	Lag *NestedInterface `json:"lag,omitempty"`

	// MAC Address
	MacAddress *string `json:"mac_address,omitempty"`

	// OOB Management
	//
	// This interface is used only for out-of-band management
	MgmtOnly bool `json:"mgmt_only,omitempty"`

	// mode
	Mode *DeviceInterfaceMode `json:"mode,omitempty"`

	// MTU
	// Maximum: 65536
	// Minimum: 1
	Mtu *int64 `json:"mtu,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// tagged vlans
	// Unique: true
	TaggedVlans []*NestedVLAN `json:"tagged_vlans"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *DeviceInterfaceType `json:"type,omitempty"`

	// untagged vlan
	UntaggedVlan *NestedVLAN `json:"untagged_vlan,omitempty"`
}

DeviceInterface device interface swagger:model DeviceInterface

func (*DeviceInterface) MarshalBinary 

func (m *DeviceInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceInterface) UnmarshalBinary 

func (m *DeviceInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceInterface) Validate 

func (m *DeviceInterface) Validate(formats strfmt.Registry) error

Validate validates this device interface

type DeviceInterfaceConnectionStatus 

type DeviceInterfaceConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

DeviceInterfaceConnectionStatus Connection status swagger:model DeviceInterfaceConnectionStatus

func (*DeviceInterfaceConnectionStatus) MarshalBinary 

func (m *DeviceInterfaceConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceInterfaceConnectionStatus) UnmarshalBinary 

func (m *DeviceInterfaceConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceInterfaceConnectionStatus) Validate 

func (m *DeviceInterfaceConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this device interface connection status

type DeviceInterfaceMode 

type DeviceInterfaceMode struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceInterfaceMode Mode swagger:model DeviceInterfaceMode

func (*DeviceInterfaceMode) MarshalBinary 

func (m *DeviceInterfaceMode) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceInterfaceMode) UnmarshalBinary 

func (m *DeviceInterfaceMode) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceInterfaceMode) Validate 

func (m *DeviceInterfaceMode) Validate(formats strfmt.Registry) error

Validate validates this device interface mode

type DeviceInterfaceType 

type DeviceInterfaceType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceInterfaceType Type swagger:model DeviceInterfaceType

func (*DeviceInterfaceType) MarshalBinary 

func (m *DeviceInterfaceType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceInterfaceType) UnmarshalBinary 

func (m *DeviceInterfaceType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceInterfaceType) Validate 

func (m *DeviceInterfaceType) Validate(formats strfmt.Registry) error

Validate validates this device interface type

type DeviceNAPALM 

type DeviceNAPALM struct {

	// Method
	// Required: true
	Method map[string]string `json:"method"`
}

DeviceNAPALM device n a p a l m swagger:model DeviceNAPALM

func (*DeviceNAPALM) MarshalBinary 

func (m *DeviceNAPALM) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceNAPALM) UnmarshalBinary 

func (m *DeviceNAPALM) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceNAPALM) Validate 

func (m *DeviceNAPALM) Validate(formats strfmt.Registry) error

Validate validates this device n a p a l m

type DeviceRole 

type DeviceRole struct {

	// Color
	// Required: true
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color *string `json:"color"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// VM Role
	//
	// Virtual machines may be assigned to this role
	VMRole bool `json:"vm_role,omitempty"`
}

DeviceRole device role swagger:model DeviceRole

func (*DeviceRole) MarshalBinary 

func (m *DeviceRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceRole) UnmarshalBinary 

func (m *DeviceRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceRole) Validate 

func (m *DeviceRole) Validate(formats strfmt.Registry) error

Validate validates this device role

type DeviceStatus 

type DeviceStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceStatus Status swagger:model DeviceStatus

func (*DeviceStatus) MarshalBinary 

func (m *DeviceStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceStatus) UnmarshalBinary 

func (m *DeviceStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceStatus) Validate 

func (m *DeviceStatus) Validate(formats strfmt.Registry) error

Validate validates this device status

type DeviceType 

type DeviceType struct {

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Front image
	// Read Only: true
	// Format: uri
	FrontImage strfmt.URI `json:"front_image,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is full depth
	//
	// Device consumes both front and rear rack faces
	IsFullDepth bool `json:"is_full_depth,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// manufacturer
	// Required: true
	Manufacturer *NestedManufacturer `json:"manufacturer"`

	// Model
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Model *string `json:"model"`

	// Part number
	//
	// Discrete part number (optional)
	// Max Length: 50
	PartNumber string `json:"part_number,omitempty"`

	// Rear image
	// Read Only: true
	// Format: uri
	RearImage strfmt.URI `json:"rear_image,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// subdevice role
	SubdeviceRole *DeviceTypeSubdeviceRole `json:"subdevice_role,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Height (U)
	// Maximum: 32767
	// Minimum: 0
	UHeight *int64 `json:"u_height,omitempty"`
}

DeviceType device type swagger:model DeviceType

func (*DeviceType) MarshalBinary 

func (m *DeviceType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceType) UnmarshalBinary 

func (m *DeviceType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceType) Validate 

func (m *DeviceType) Validate(formats strfmt.Registry) error

Validate validates this device type

type DeviceTypeSubdeviceRole 

type DeviceTypeSubdeviceRole struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceTypeSubdeviceRole Subdevice role swagger:model DeviceTypeSubdeviceRole

func (*DeviceTypeSubdeviceRole) MarshalBinary 

func (m *DeviceTypeSubdeviceRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceTypeSubdeviceRole) UnmarshalBinary 

func (m *DeviceTypeSubdeviceRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceTypeSubdeviceRole) Validate 

func (m *DeviceTypeSubdeviceRole) Validate(formats strfmt.Registry) error

Validate validates this device type subdevice role

type DeviceWithConfigContext 

type DeviceWithConfigContext struct {

	// Asset tag
	//
	// A unique tag used to identify this device
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// cluster
	Cluster *NestedCluster `json:"cluster,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Config context
	// Read Only: true
	ConfigContext map[string]string `json:"config_context,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// device role
	// Required: true
	DeviceRole *NestedDeviceRole `json:"device_role"`

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// face
	Face *DeviceWithConfigContextFace `json:"face,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

	// parent device
	ParentDevice *NestedDevice `json:"parent_device,omitempty"`

	// platform
	Platform *NestedPlatform `json:"platform,omitempty"`

	// Position (U)
	//
	// The lowest-numbered unit occupied by the device
	// Maximum: 32767
	// Minimum: 1
	Position *int64 `json:"position,omitempty"`

	// primary ip
	PrimaryIP *NestedIPAddress `json:"primary_ip,omitempty"`

	// primary ip4
	PrimaryIp4 *NestedIPAddress `json:"primary_ip4,omitempty"`

	// primary ip6
	PrimaryIp6 *NestedIPAddress `json:"primary_ip6,omitempty"`

	// rack
	Rack *NestedRack `json:"rack,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// status
	Status *DeviceWithConfigContextStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// Vc position
	// Maximum: 255
	// Minimum: 0
	VcPosition *int64 `json:"vc_position,omitempty"`

	// Vc priority
	// Maximum: 255
	// Minimum: 0
	VcPriority *int64 `json:"vc_priority,omitempty"`

	// virtual chassis
	VirtualChassis *NestedVirtualChassis `json:"virtual_chassis,omitempty"`
}

DeviceWithConfigContext device with config context swagger:model DeviceWithConfigContext

func (*DeviceWithConfigContext) MarshalBinary 

func (m *DeviceWithConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceWithConfigContext) UnmarshalBinary 

func (m *DeviceWithConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceWithConfigContext) Validate 

func (m *DeviceWithConfigContext) Validate(formats strfmt.Registry) error

Validate validates this device with config context

type DeviceWithConfigContextFace 

type DeviceWithConfigContextFace struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceWithConfigContextFace Face swagger:model DeviceWithConfigContextFace

func (*DeviceWithConfigContextFace) MarshalBinary 

func (m *DeviceWithConfigContextFace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceWithConfigContextFace) UnmarshalBinary 

func (m *DeviceWithConfigContextFace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceWithConfigContextFace) Validate 

func (m *DeviceWithConfigContextFace) Validate(formats strfmt.Registry) error

Validate validates this device with config context face

type DeviceWithConfigContextStatus 

type DeviceWithConfigContextStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

DeviceWithConfigContextStatus Status swagger:model DeviceWithConfigContextStatus

func (*DeviceWithConfigContextStatus) MarshalBinary 

func (m *DeviceWithConfigContextStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*DeviceWithConfigContextStatus) UnmarshalBinary 

func (m *DeviceWithConfigContextStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*DeviceWithConfigContextStatus) Validate 

func (m *DeviceWithConfigContextStatus) Validate(formats strfmt.Registry) error

Validate validates this device with config context status

type ExportTemplate 

type ExportTemplate struct {

	// Content type
	// Required: true
	ContentType *string `json:"content_type"`

	// Description
	// Max Length: 200
	Description string `json:"description,omitempty"`

	// File extension
	//
	// Extension to append to the rendered filename
	// Max Length: 15
	FileExtension string `json:"file_extension,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// MIME type
	//
	// Defaults to <code>text/plain</code>
	// Max Length: 50
	MimeType string `json:"mime_type,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Template code
	//
	// The list of objects being exported is passed as a context variable named <code>queryset</code>.
	// Required: true
	// Min Length: 1
	TemplateCode *string `json:"template_code"`

	// template language
	TemplateLanguage *ExportTemplateTemplateLanguage `json:"template_language,omitempty"`
}

ExportTemplate export template swagger:model ExportTemplate

func (*ExportTemplate) MarshalBinary 

func (m *ExportTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ExportTemplate) UnmarshalBinary 

func (m *ExportTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ExportTemplate) Validate 

func (m *ExportTemplate) Validate(formats strfmt.Registry) error

Validate validates this export template

type ExportTemplateTemplateLanguage 

type ExportTemplateTemplateLanguage struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ExportTemplateTemplateLanguage Template language swagger:model ExportTemplateTemplateLanguage

func (*ExportTemplateTemplateLanguage) MarshalBinary 

func (m *ExportTemplateTemplateLanguage) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ExportTemplateTemplateLanguage) UnmarshalBinary 

func (m *ExportTemplateTemplateLanguage) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ExportTemplateTemplateLanguage) UnmarshalJSON 

func (m *ExportTemplateTemplateLanguage) UnmarshalJSON(b []byte) error

func (*ExportTemplateTemplateLanguage) Validate 

func (m *ExportTemplateTemplateLanguage) Validate(formats strfmt.Registry) error

Validate validates this export template template language

type FrontPort 

type FrontPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// rear port
	// Required: true
	RearPort *FrontPortRearPort `json:"rear_port"`

	// Rear port position
	// Maximum: 64
	// Minimum: 1
	RearPortPosition int64 `json:"rear_port_position,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// type
	// Required: true
	Type *FrontPortType `json:"type"`
}

FrontPort front port swagger:model FrontPort

func (*FrontPort) MarshalBinary 

func (m *FrontPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontPort) UnmarshalBinary 

func (m *FrontPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontPort) Validate 

func (m *FrontPort) Validate(formats strfmt.Registry) error

Validate validates this front port

type FrontPortRearPort 

type FrontPortRearPort struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

FrontPortRearPort Rear port swagger:model FrontPortRearPort

func (*FrontPortRearPort) MarshalBinary 

func (m *FrontPortRearPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontPortRearPort) UnmarshalBinary 

func (m *FrontPortRearPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontPortRearPort) Validate 

func (m *FrontPortRearPort) Validate(formats strfmt.Registry) error

Validate validates this front port rear port

type FrontPortTemplate 

type FrontPortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// rear port
	// Required: true
	RearPort *NestedRearPortTemplate `json:"rear_port"`

	// Rear port position
	// Maximum: 64
	// Minimum: 1
	RearPortPosition int64 `json:"rear_port_position,omitempty"`

	// type
	// Required: true
	Type *FrontPortTemplateType `json:"type"`
}

FrontPortTemplate front port template swagger:model FrontPortTemplate

func (*FrontPortTemplate) MarshalBinary 

func (m *FrontPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontPortTemplate) UnmarshalBinary 

func (m *FrontPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontPortTemplate) Validate 

func (m *FrontPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this front port template

type FrontPortTemplateType 

type FrontPortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

FrontPortTemplateType Type swagger:model FrontPortTemplateType

func (*FrontPortTemplateType) MarshalBinary 

func (m *FrontPortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontPortTemplateType) UnmarshalBinary 

func (m *FrontPortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontPortTemplateType) Validate 

func (m *FrontPortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this front port template type

type FrontPortType 

type FrontPortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

FrontPortType Type swagger:model FrontPortType

func (*FrontPortType) MarshalBinary 

func (m *FrontPortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*FrontPortType) UnmarshalBinary 

func (m *FrontPortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*FrontPortType) Validate 

func (m *FrontPortType) Validate(formats strfmt.Registry) error

Validate validates this front port type

type Graph 

type Graph struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Link URL
	// Max Length: 200
	// Format: uri
	Link strfmt.URI `json:"link,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Source URL
	// Required: true
	// Max Length: 500
	// Min Length: 1
	Source *string `json:"source"`

	// Template language
	// Enum: [django jinja2]
	TemplateLanguage string `json:"template_language,omitempty"`

	// Type
	// Required: true
	Type *string `json:"type"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

Graph graph swagger:model Graph

func (*Graph) MarshalBinary 

func (m *Graph) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Graph) UnmarshalBinary 

func (m *Graph) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Graph) Validate 

func (m *Graph) Validate(formats strfmt.Registry) error

Validate validates this graph

type IPAddress 

type IPAddress struct {

	// Address
	//
	// IPv4 or IPv6 address (with mask)
	// Required: true
	Address *string `json:"address"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// DNS Name
	//
	// Hostname or FQDN (not case-sensitive)
	// Max Length: 255
	// Pattern: ^[0-9A-Za-z._-]+$
	DNSName string `json:"dns_name,omitempty"`

	// family
	Family *IPAddressFamily `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// interface
	Interface *IPAddressInterface `json:"interface,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// nat inside
	NatInside *NestedIPAddress `json:"nat_inside,omitempty"`

	// nat outside
	NatOutside *NestedIPAddress `json:"nat_outside,omitempty"`

	// role
	Role *IPAddressRole `json:"role,omitempty"`

	// status
	Status *IPAddressStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// vrf
	Vrf *NestedVRF `json:"vrf,omitempty"`
}

IPAddress IP address swagger:model IPAddress

func (*IPAddress) MarshalBinary 

func (m *IPAddress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IPAddress) UnmarshalBinary 

func (m *IPAddress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IPAddress) Validate 

func (m *IPAddress) Validate(formats strfmt.Registry) error

Validate validates this IP address

type IPAddressFamily 

type IPAddressFamily struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *int64 `json:"value"`
}

IPAddressFamily Family swagger:model IPAddressFamily

func (*IPAddressFamily) MarshalBinary 

func (m *IPAddressFamily) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IPAddressFamily) UnmarshalBinary 

func (m *IPAddressFamily) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IPAddressFamily) Validate 

func (m *IPAddressFamily) Validate(formats strfmt.Registry) error

Validate validates this IP address family

type IPAddressInterface 

type IPAddressInterface struct {

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	URL string `json:"url,omitempty"`

	// virtual machine
	VirtualMachine *NestedVirtualMachine `json:"virtual_machine,omitempty"`
}

IPAddressInterface Interface swagger:model IPAddressInterface

func (*IPAddressInterface) MarshalBinary 

func (m *IPAddressInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IPAddressInterface) UnmarshalBinary 

func (m *IPAddressInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IPAddressInterface) Validate 

func (m *IPAddressInterface) Validate(formats strfmt.Registry) error

Validate validates this IP address interface

type IPAddressRole 

type IPAddressRole struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

IPAddressRole Role swagger:model IPAddressRole

func (*IPAddressRole) MarshalBinary 

func (m *IPAddressRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IPAddressRole) UnmarshalBinary 

func (m *IPAddressRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IPAddressRole) Validate 

func (m *IPAddressRole) Validate(formats strfmt.Registry) error

Validate validates this IP address role

type IPAddressStatus 

type IPAddressStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

IPAddressStatus Status swagger:model IPAddressStatus

func (*IPAddressStatus) MarshalBinary 

func (m *IPAddressStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*IPAddressStatus) UnmarshalBinary 

func (m *IPAddressStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*IPAddressStatus) Validate 

func (m *IPAddressStatus) Validate(formats strfmt.Registry) error

Validate validates this IP address status

type ImageAttachment 

type ImageAttachment struct {

	// Content type
	// Required: true
	ContentType *string `json:"content_type"`

	// Created
	// Read Only: true
	// Format: date-time
	Created strfmt.DateTime `json:"created,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Image
	// Read Only: true
	// Format: uri
	Image strfmt.URI `json:"image,omitempty"`

	// Image height
	// Required: true
	// Maximum: 32767
	// Minimum: 0
	ImageHeight *int64 `json:"image_height"`

	// Image width
	// Required: true
	// Maximum: 32767
	// Minimum: 0
	ImageWidth *int64 `json:"image_width"`

	// Name
	// Max Length: 50
	Name string `json:"name,omitempty"`

	// Object id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	ObjectID *int64 `json:"object_id"`

	// Parent
	// Read Only: true
	Parent map[string]string `json:"parent,omitempty"`
}

ImageAttachment image attachment swagger:model ImageAttachment

func (*ImageAttachment) MarshalBinary 

func (m *ImageAttachment) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ImageAttachment) UnmarshalBinary 

func (m *ImageAttachment) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ImageAttachment) Validate 

func (m *ImageAttachment) Validate(formats strfmt.Registry) error

Validate validates this image attachment

type InterfaceConnection 

type InterfaceConnection struct {

	// connection status
	ConnectionStatus *InterfaceConnectionConnectionStatus `json:"connection_status,omitempty"`

	// interface a
	Interfacea *NestedInterface `json:"interface_a,omitempty"`

	// interface b
	// Required: true
	Interfaceb *NestedInterface `json:"interface_b"`
}

InterfaceConnection interface connection swagger:model InterfaceConnection

func (*InterfaceConnection) MarshalBinary 

func (m *InterfaceConnection) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InterfaceConnection) UnmarshalBinary 

func (m *InterfaceConnection) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InterfaceConnection) Validate 

func (m *InterfaceConnection) Validate(formats strfmt.Registry) error

Validate validates this interface connection

type InterfaceConnectionConnectionStatus 

type InterfaceConnectionConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

InterfaceConnectionConnectionStatus Connection status swagger:model InterfaceConnectionConnectionStatus

func (*InterfaceConnectionConnectionStatus) MarshalBinary 

func (m *InterfaceConnectionConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InterfaceConnectionConnectionStatus) UnmarshalBinary 

func (m *InterfaceConnectionConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InterfaceConnectionConnectionStatus) Validate 

func (m *InterfaceConnectionConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this interface connection connection status

type InterfaceTemplate 

type InterfaceTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Management only
	MgmtOnly bool `json:"mgmt_only,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// type
	Type *InterfaceTemplateType `json:"type,omitempty"`
}

InterfaceTemplate interface template swagger:model InterfaceTemplate

func (*InterfaceTemplate) MarshalBinary 

func (m *InterfaceTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InterfaceTemplate) UnmarshalBinary 

func (m *InterfaceTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InterfaceTemplate) Validate 

func (m *InterfaceTemplate) Validate(formats strfmt.Registry) error

Validate validates this interface template

type InterfaceTemplateType 

type InterfaceTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

InterfaceTemplateType Type swagger:model InterfaceTemplateType

func (*InterfaceTemplateType) MarshalBinary 

func (m *InterfaceTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InterfaceTemplateType) UnmarshalBinary 

func (m *InterfaceTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InterfaceTemplateType) Validate 

func (m *InterfaceTemplateType) Validate(formats strfmt.Registry) error

Validate validates this interface template type

type InventoryItem 

type InventoryItem struct {

	// Asset tag
	//
	// A unique tag used to identify this item
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Discovered
	Discovered bool `json:"discovered,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Parent
	Parent *int64 `json:"parent,omitempty"`

	// Part ID
	// Max Length: 50
	PartID string `json:"part_id,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// tags
	Tags []string `json:"tags"`
}

InventoryItem inventory item swagger:model InventoryItem

func (*InventoryItem) MarshalBinary 

func (m *InventoryItem) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*InventoryItem) UnmarshalBinary 

func (m *InventoryItem) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*InventoryItem) Validate 

func (m *InventoryItem) Validate(formats strfmt.Registry) error

Validate validates this inventory item

type Manufacturer 

type Manufacturer struct {

	// Devicetype count
	// Read Only: true
	DevicetypeCount int64 `json:"devicetype_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Inventoryitem count
	// Read Only: true
	InventoryitemCount int64 `json:"inventoryitem_count,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Platform count
	// Read Only: true
	PlatformCount int64 `json:"platform_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

Manufacturer manufacturer swagger:model Manufacturer

func (*Manufacturer) MarshalBinary 

func (m *Manufacturer) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Manufacturer) UnmarshalBinary 

func (m *Manufacturer) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Manufacturer) Validate 

func (m *Manufacturer) Validate(formats strfmt.Registry) error

Validate validates this manufacturer

type NestedCable 

type NestedCable struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Label
	// Max Length: 100
	Label string `json:"label,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedCable Cable swagger:model NestedCable

func (*NestedCable) MarshalBinary 

func (m *NestedCable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedCable) UnmarshalBinary 

func (m *NestedCable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedCable) Validate 

func (m *NestedCable) Validate(formats strfmt.Registry) error

Validate validates this nested cable

type NestedCircuit 

type NestedCircuit struct {

	// Circuit ID
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Cid *string `json:"cid"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedCircuit Circuit swagger:model NestedCircuit

func (*NestedCircuit) MarshalBinary 

func (m *NestedCircuit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedCircuit) UnmarshalBinary 

func (m *NestedCircuit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedCircuit) Validate 

func (m *NestedCircuit) Validate(formats strfmt.Registry) error

Validate validates this nested circuit

type NestedCircuitType 

type NestedCircuitType struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedCircuitType Type swagger:model NestedCircuitType

func (*NestedCircuitType) MarshalBinary 

func (m *NestedCircuitType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedCircuitType) UnmarshalBinary 

func (m *NestedCircuitType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedCircuitType) Validate 

func (m *NestedCircuitType) Validate(formats strfmt.Registry) error

Validate validates this nested circuit type

type NestedCluster 

type NestedCluster struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

NestedCluster Cluster swagger:model NestedCluster

func (*NestedCluster) MarshalBinary 

func (m *NestedCluster) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedCluster) UnmarshalBinary 

func (m *NestedCluster) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedCluster) Validate 

func (m *NestedCluster) Validate(formats strfmt.Registry) error

Validate validates this nested cluster

type NestedClusterGroup 

type NestedClusterGroup struct {

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedClusterGroup nested cluster group swagger:model NestedClusterGroup

func (*NestedClusterGroup) MarshalBinary 

func (m *NestedClusterGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedClusterGroup) UnmarshalBinary 

func (m *NestedClusterGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedClusterGroup) Validate 

func (m *NestedClusterGroup) Validate(formats strfmt.Registry) error

Validate validates this nested cluster group

type NestedClusterType 

type NestedClusterType struct {

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedClusterType Type swagger:model NestedClusterType

func (*NestedClusterType) MarshalBinary 

func (m *NestedClusterType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedClusterType) UnmarshalBinary 

func (m *NestedClusterType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedClusterType) Validate 

func (m *NestedClusterType) Validate(formats strfmt.Registry) error

Validate validates this nested cluster type

type NestedDevice 

type NestedDevice struct {

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedDevice Device swagger:model NestedDevice

func (*NestedDevice) MarshalBinary 

func (m *NestedDevice) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedDevice) UnmarshalBinary 

func (m *NestedDevice) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedDevice) Validate 

func (m *NestedDevice) Validate(formats strfmt.Registry) error

Validate validates this nested device

type NestedDeviceRole 

type NestedDeviceRole struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

NestedDeviceRole Device role swagger:model NestedDeviceRole

func (*NestedDeviceRole) MarshalBinary 

func (m *NestedDeviceRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedDeviceRole) UnmarshalBinary 

func (m *NestedDeviceRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedDeviceRole) Validate 

func (m *NestedDeviceRole) Validate(formats strfmt.Registry) error

Validate validates this nested device role

type NestedDeviceType 

type NestedDeviceType struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

	// Model
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Model *string `json:"model"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedDeviceType Device type swagger:model NestedDeviceType

func (*NestedDeviceType) MarshalBinary 

func (m *NestedDeviceType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedDeviceType) UnmarshalBinary 

func (m *NestedDeviceType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedDeviceType) Validate 

func (m *NestedDeviceType) Validate(formats strfmt.Registry) error

Validate validates this nested device type

type NestedIPAddress 

type NestedIPAddress struct {

	// Address
	//
	// IPv4 or IPv6 address (with mask)
	// Required: true
	Address *string `json:"address"`

	// Family
	// Read Only: true
	Family int64 `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedIPAddress Primary ip swagger:model NestedIPAddress

func (*NestedIPAddress) MarshalBinary 

func (m *NestedIPAddress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedIPAddress) UnmarshalBinary 

func (m *NestedIPAddress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedIPAddress) Validate 

func (m *NestedIPAddress) Validate(formats strfmt.Registry) error

Validate validates this nested IP address

type NestedInterface 

type NestedInterface struct {

	// Cable
	Cable *int64 `json:"cable,omitempty"`

	// connection status
	ConnectionStatus *NestedInterfaceConnectionStatus `json:"connection_status,omitempty"`

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedInterface Connected endpoint swagger:model NestedInterface

func (*NestedInterface) MarshalBinary 

func (m *NestedInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedInterface) UnmarshalBinary 

func (m *NestedInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedInterface) Validate 

func (m *NestedInterface) Validate(formats strfmt.Registry) error

Validate validates this nested interface

type NestedInterfaceConnectionStatus 

type NestedInterfaceConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

NestedInterfaceConnectionStatus Connection status swagger:model NestedInterfaceConnectionStatus

func (*NestedInterfaceConnectionStatus) MarshalBinary 

func (m *NestedInterfaceConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedInterfaceConnectionStatus) UnmarshalBinary 

func (m *NestedInterfaceConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedInterfaceConnectionStatus) Validate 

func (m *NestedInterfaceConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this nested interface connection status

type NestedManufacturer 

type NestedManufacturer struct {

	// Devicetype count
	// Read Only: true
	DevicetypeCount int64 `json:"devicetype_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedManufacturer Manufacturer swagger:model NestedManufacturer

func (*NestedManufacturer) MarshalBinary 

func (m *NestedManufacturer) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedManufacturer) UnmarshalBinary 

func (m *NestedManufacturer) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedManufacturer) Validate 

func (m *NestedManufacturer) Validate(formats strfmt.Registry) error

Validate validates this nested manufacturer

type NestedPlatform 

type NestedPlatform struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 100
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

NestedPlatform Platform swagger:model NestedPlatform

func (*NestedPlatform) MarshalBinary 

func (m *NestedPlatform) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedPlatform) UnmarshalBinary 

func (m *NestedPlatform) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedPlatform) Validate 

func (m *NestedPlatform) Validate(formats strfmt.Registry) error

Validate validates this nested platform

type NestedPowerPanel 

type NestedPowerPanel struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedPowerPanel Power panel swagger:model NestedPowerPanel

func (*NestedPowerPanel) MarshalBinary 

func (m *NestedPowerPanel) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedPowerPanel) UnmarshalBinary 

func (m *NestedPowerPanel) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedPowerPanel) Validate 

func (m *NestedPowerPanel) Validate(formats strfmt.Registry) error

Validate validates this nested power panel

type NestedPowerPort 

type NestedPowerPort struct {

	// Cable
	Cable *int64 `json:"cable,omitempty"`

	// connection status
	ConnectionStatus *NestedPowerPortConnectionStatus `json:"connection_status,omitempty"`

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedPowerPort Power port swagger:model NestedPowerPort

func (*NestedPowerPort) MarshalBinary 

func (m *NestedPowerPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedPowerPort) UnmarshalBinary 

func (m *NestedPowerPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedPowerPort) Validate 

func (m *NestedPowerPort) Validate(formats strfmt.Registry) error

Validate validates this nested power port

type NestedPowerPortConnectionStatus 

type NestedPowerPortConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

NestedPowerPortConnectionStatus Connection status swagger:model NestedPowerPortConnectionStatus

func (*NestedPowerPortConnectionStatus) MarshalBinary 

func (m *NestedPowerPortConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedPowerPortConnectionStatus) UnmarshalBinary 

func (m *NestedPowerPortConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedPowerPortConnectionStatus) Validate 

func (m *NestedPowerPortConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this nested power port connection status

type NestedPowerPortTemplate 

type NestedPowerPortTemplate struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedPowerPortTemplate Power port swagger:model NestedPowerPortTemplate

func (*NestedPowerPortTemplate) MarshalBinary 

func (m *NestedPowerPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedPowerPortTemplate) UnmarshalBinary 

func (m *NestedPowerPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedPowerPortTemplate) Validate 

func (m *NestedPowerPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this nested power port template

type NestedProvider 

type NestedProvider struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedProvider Provider swagger:model NestedProvider

func (*NestedProvider) MarshalBinary 

func (m *NestedProvider) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedProvider) UnmarshalBinary 

func (m *NestedProvider) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedProvider) Validate 

func (m *NestedProvider) Validate(formats strfmt.Registry) error

Validate validates this nested provider

type NestedRIR 

type NestedRIR struct {

	// Aggregate count
	// Read Only: true
	AggregateCount int64 `json:"aggregate_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRIR Rir swagger:model NestedRIR

func (*NestedRIR) MarshalBinary 

func (m *NestedRIR) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRIR) UnmarshalBinary 

func (m *NestedRIR) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRIR) Validate 

func (m *NestedRIR) Validate(formats strfmt.Registry) error

Validate validates this nested r i r

type NestedRack 

type NestedRack struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRack Rack swagger:model NestedRack

func (*NestedRack) MarshalBinary 

func (m *NestedRack) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRack) UnmarshalBinary 

func (m *NestedRack) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRack) Validate 

func (m *NestedRack) Validate(formats strfmt.Registry) error

Validate validates this nested rack

type NestedRackGroup 

type NestedRackGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRackGroup Rack group swagger:model NestedRackGroup

func (*NestedRackGroup) MarshalBinary 

func (m *NestedRackGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRackGroup) UnmarshalBinary 

func (m *NestedRackGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRackGroup) Validate 

func (m *NestedRackGroup) Validate(formats strfmt.Registry) error

Validate validates this nested rack group

type NestedRackRole 

type NestedRackRole struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRackRole Role swagger:model NestedRackRole

func (*NestedRackRole) MarshalBinary 

func (m *NestedRackRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRackRole) UnmarshalBinary 

func (m *NestedRackRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRackRole) Validate 

func (m *NestedRackRole) Validate(formats strfmt.Registry) error

Validate validates this nested rack role

type NestedRearPortTemplate 

type NestedRearPortTemplate struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRearPortTemplate Rear port swagger:model NestedRearPortTemplate

func (*NestedRearPortTemplate) MarshalBinary 

func (m *NestedRearPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRearPortTemplate) UnmarshalBinary 

func (m *NestedRearPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRearPortTemplate) Validate 

func (m *NestedRearPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this nested rear port template

type NestedRegion 

type NestedRegion struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedRegion Parent swagger:model NestedRegion

func (*NestedRegion) MarshalBinary 

func (m *NestedRegion) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRegion) UnmarshalBinary 

func (m *NestedRegion) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRegion) Validate 

func (m *NestedRegion) Validate(formats strfmt.Registry) error

Validate validates this nested region

type NestedRole 

type NestedRole struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

NestedRole Role swagger:model NestedRole

func (*NestedRole) MarshalBinary 

func (m *NestedRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedRole) UnmarshalBinary 

func (m *NestedRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedRole) Validate 

func (m *NestedRole) Validate(formats strfmt.Registry) error

Validate validates this nested role

type NestedSecretRole 

type NestedSecretRole struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Secret count
	// Read Only: true
	SecretCount int64 `json:"secret_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedSecretRole Role swagger:model NestedSecretRole

func (*NestedSecretRole) MarshalBinary 

func (m *NestedSecretRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedSecretRole) UnmarshalBinary 

func (m *NestedSecretRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedSecretRole) Validate 

func (m *NestedSecretRole) Validate(formats strfmt.Registry) error

Validate validates this nested secret role

type NestedSite 

type NestedSite struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedSite Site swagger:model NestedSite

func (*NestedSite) MarshalBinary 

func (m *NestedSite) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedSite) UnmarshalBinary 

func (m *NestedSite) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedSite) Validate 

func (m *NestedSite) Validate(formats strfmt.Registry) error

Validate validates this nested site

type NestedTenant 

type NestedTenant struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedTenant Tenant swagger:model NestedTenant

func (*NestedTenant) MarshalBinary 

func (m *NestedTenant) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedTenant) UnmarshalBinary 

func (m *NestedTenant) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedTenant) Validate 

func (m *NestedTenant) Validate(formats strfmt.Registry) error

Validate validates this nested tenant

type NestedTenantGroup 

type NestedTenantGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Tenant count
	// Read Only: true
	TenantCount int64 `json:"tenant_count,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedTenantGroup nested tenant group swagger:model NestedTenantGroup

func (*NestedTenantGroup) MarshalBinary 

func (m *NestedTenantGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedTenantGroup) UnmarshalBinary 

func (m *NestedTenantGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedTenantGroup) Validate 

func (m *NestedTenantGroup) Validate(formats strfmt.Registry) error

Validate validates this nested tenant group

type NestedUser 

type NestedUser struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Username
	//
	// Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.
	// Required: true
	// Max Length: 150
	// Min Length: 1
	// Pattern: ^[\w.@+-]+$
	Username *string `json:"username"`
}

NestedUser User swagger:model NestedUser

func (*NestedUser) MarshalBinary 

func (m *NestedUser) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedUser) UnmarshalBinary 

func (m *NestedUser) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedUser) Validate 

func (m *NestedUser) Validate(formats strfmt.Registry) error

Validate validates this nested user

type NestedVLAN 

type NestedVLAN struct {

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// ID
	// Required: true
	// Maximum: 4094
	// Minimum: 1
	Vid *int64 `json:"vid"`
}

NestedVLAN Untagged vlan swagger:model NestedVLAN

func (*NestedVLAN) MarshalBinary 

func (m *NestedVLAN) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedVLAN) UnmarshalBinary 

func (m *NestedVLAN) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedVLAN) Validate 

func (m *NestedVLAN) Validate(formats strfmt.Registry) error

Validate validates this nested v l a n

type NestedVLANGroup 

type NestedVLANGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

NestedVLANGroup Group swagger:model NestedVLANGroup

func (*NestedVLANGroup) MarshalBinary 

func (m *NestedVLANGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedVLANGroup) UnmarshalBinary 

func (m *NestedVLANGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedVLANGroup) Validate 

func (m *NestedVLANGroup) Validate(formats strfmt.Registry) error

Validate validates this nested v l a n group

type NestedVRF 

type NestedVRF struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Route distinguisher
	// Max Length: 21
	Rd *string `json:"rd,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedVRF Vrf swagger:model NestedVRF

func (*NestedVRF) MarshalBinary 

func (m *NestedVRF) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedVRF) UnmarshalBinary 

func (m *NestedVRF) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedVRF) Validate 

func (m *NestedVRF) Validate(formats strfmt.Registry) error

Validate validates this nested v r f

type NestedVirtualChassis 

type NestedVirtualChassis struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// master
	// Required: true
	Master *NestedDevice `json:"master"`

	// Member count
	// Read Only: true
	MemberCount int64 `json:"member_count,omitempty"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedVirtualChassis Virtual chassis swagger:model NestedVirtualChassis

func (*NestedVirtualChassis) MarshalBinary 

func (m *NestedVirtualChassis) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedVirtualChassis) UnmarshalBinary 

func (m *NestedVirtualChassis) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedVirtualChassis) Validate 

func (m *NestedVirtualChassis) Validate(formats strfmt.Registry) error

Validate validates this nested virtual chassis

type NestedVirtualMachine 

type NestedVirtualMachine struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Url
	// Read Only: true
	// Format: uri
	URL strfmt.URI `json:"url,omitempty"`
}

NestedVirtualMachine Virtual machine swagger:model NestedVirtualMachine

func (*NestedVirtualMachine) MarshalBinary 

func (m *NestedVirtualMachine) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*NestedVirtualMachine) UnmarshalBinary 

func (m *NestedVirtualMachine) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*NestedVirtualMachine) Validate 

func (m *NestedVirtualMachine) Validate(formats strfmt.Registry) error

Validate validates this nested virtual machine

type ObjectChange 

type ObjectChange struct {

	// action
	Action *ObjectChangeAction `json:"action,omitempty"`

	// Changed object
	//
	//
	//         Serialize a nested representation of the changed object.
	//
	// Read Only: true
	ChangedObject map[string]string `json:"changed_object,omitempty"`

	// Changed object id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	ChangedObjectID *int64 `json:"changed_object_id"`

	// Changed object type
	// Read Only: true
	ChangedObjectType string `json:"changed_object_type,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Object data
	// Read Only: true
	ObjectData string `json:"object_data,omitempty"`

	// Request id
	// Read Only: true
	// Format: uuid
	RequestID strfmt.UUID `json:"request_id,omitempty"`

	// Time
	// Read Only: true
	// Format: date-time
	Time strfmt.DateTime `json:"time,omitempty"`

	// user
	User *NestedUser `json:"user,omitempty"`

	// User name
	// Read Only: true
	// Min Length: 1
	UserName string `json:"user_name,omitempty"`
}

ObjectChange object change swagger:model ObjectChange

func (*ObjectChange) MarshalBinary 

func (m *ObjectChange) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ObjectChange) UnmarshalBinary 

func (m *ObjectChange) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ObjectChange) Validate 

func (m *ObjectChange) Validate(formats strfmt.Registry) error

Validate validates this object change

type ObjectChangeAction 

type ObjectChangeAction struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ObjectChangeAction Action swagger:model ObjectChangeAction

func (*ObjectChangeAction) MarshalBinary 

func (m *ObjectChangeAction) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ObjectChangeAction) UnmarshalBinary 

func (m *ObjectChangeAction) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ObjectChangeAction) Validate 

func (m *ObjectChangeAction) Validate(formats strfmt.Registry) error

Validate validates this object change action

type Platform 

type Platform struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// NAPALM arguments
	//
	// Additional arguments to pass when initiating the NAPALM driver (JSON format)
	NapalmArgs *string `json:"napalm_args,omitempty"`

	// NAPALM driver
	//
	// The name of the NAPALM driver to use when interacting with devices
	// Max Length: 50
	NapalmDriver string `json:"napalm_driver,omitempty"`

	// Slug
	// Required: true
	// Max Length: 100
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

Platform platform swagger:model Platform

func (*Platform) MarshalBinary 

func (m *Platform) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Platform) UnmarshalBinary 

func (m *Platform) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Platform) Validate 

func (m *Platform) Validate(formats strfmt.Registry) error

Validate validates this platform

type PowerFeed 

type PowerFeed struct {

	// Amperage
	// Maximum: 32767
	// Minimum: 1
	Amperage int64 `json:"amperage,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Max utilization
	//
	// Maximum permissible draw (percentage)
	// Maximum: 100
	// Minimum: 1
	MaxUtilization int64 `json:"max_utilization,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// phase
	Phase *PowerFeedPhase `json:"phase,omitempty"`

	// power panel
	// Required: true
	PowerPanel *NestedPowerPanel `json:"power_panel"`

	// rack
	Rack *NestedRack `json:"rack,omitempty"`

	// status
	Status *PowerFeedStatus `json:"status,omitempty"`

	// supply
	Supply *PowerFeedSupply `json:"supply,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *PowerFeedType `json:"type,omitempty"`

	// Voltage
	// Maximum: 32767
	// Minimum: 1
	Voltage int64 `json:"voltage,omitempty"`
}

PowerFeed power feed swagger:model PowerFeed

func (*PowerFeed) MarshalBinary 

func (m *PowerFeed) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerFeed) UnmarshalBinary 

func (m *PowerFeed) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerFeed) Validate 

func (m *PowerFeed) Validate(formats strfmt.Registry) error

Validate validates this power feed

type PowerFeedPhase 

type PowerFeedPhase struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerFeedPhase Phase swagger:model PowerFeedPhase

func (*PowerFeedPhase) MarshalBinary 

func (m *PowerFeedPhase) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerFeedPhase) UnmarshalBinary 

func (m *PowerFeedPhase) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerFeedPhase) UnmarshalJSON 

func (m *PowerFeedPhase) UnmarshalJSON(b []byte) error

func (*PowerFeedPhase) Validate 

func (m *PowerFeedPhase) Validate(formats strfmt.Registry) error

Validate validates this power feed phase

type PowerFeedStatus 

type PowerFeedStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerFeedStatus Status swagger:model PowerFeedStatus

func (*PowerFeedStatus) MarshalBinary 

func (m *PowerFeedStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerFeedStatus) UnmarshalBinary 

func (m *PowerFeedStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerFeedStatus) UnmarshalJSON 

func (m *PowerFeedStatus) UnmarshalJSON(b []byte) error

func (*PowerFeedStatus) Validate 

func (m *PowerFeedStatus) Validate(formats strfmt.Registry) error

Validate validates this power feed status

type PowerFeedSupply 

type PowerFeedSupply struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerFeedSupply Supply swagger:model PowerFeedSupply

func (*PowerFeedSupply) MarshalBinary 

func (m *PowerFeedSupply) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerFeedSupply) UnmarshalBinary 

func (m *PowerFeedSupply) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerFeedSupply) UnmarshalJSON 

func (m *PowerFeedSupply) UnmarshalJSON(b []byte) error

func (*PowerFeedSupply) Validate 

func (m *PowerFeedSupply) Validate(formats strfmt.Registry) error

Validate validates this power feed supply

type PowerFeedType 

type PowerFeedType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerFeedType Type swagger:model PowerFeedType

func (*PowerFeedType) MarshalBinary 

func (m *PowerFeedType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerFeedType) UnmarshalBinary 

func (m *PowerFeedType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerFeedType) UnmarshalJSON 

func (m *PowerFeedType) UnmarshalJSON(b []byte) error

func (*PowerFeedType) Validate 

func (m *PowerFeedType) Validate(formats strfmt.Registry) error

Validate validates this power feed type

type PowerOutlet 

type PowerOutlet struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *PowerOutletConnectionStatus `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// feed leg
	FeedLeg *PowerOutletFeedLeg `json:"feed_leg,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// power port
	PowerPort *NestedPowerPort `json:"power_port,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *PowerOutletType `json:"type,omitempty"`
}

PowerOutlet power outlet swagger:model PowerOutlet

func (*PowerOutlet) MarshalBinary 

func (m *PowerOutlet) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutlet) UnmarshalBinary 

func (m *PowerOutlet) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutlet) Validate 

func (m *PowerOutlet) Validate(formats strfmt.Registry) error

Validate validates this power outlet

type PowerOutletConnectionStatus 

type PowerOutletConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

PowerOutletConnectionStatus Connection status swagger:model PowerOutletConnectionStatus

func (*PowerOutletConnectionStatus) MarshalBinary 

func (m *PowerOutletConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletConnectionStatus) UnmarshalBinary 

func (m *PowerOutletConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletConnectionStatus) Validate 

func (m *PowerOutletConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this power outlet connection status

type PowerOutletFeedLeg 

type PowerOutletFeedLeg struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerOutletFeedLeg Feed leg swagger:model PowerOutletFeedLeg

func (*PowerOutletFeedLeg) MarshalBinary 

func (m *PowerOutletFeedLeg) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletFeedLeg) UnmarshalBinary 

func (m *PowerOutletFeedLeg) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletFeedLeg) Validate 

func (m *PowerOutletFeedLeg) Validate(formats strfmt.Registry) error

Validate validates this power outlet feed leg

type PowerOutletTemplate 

type PowerOutletTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// feed leg
	FeedLeg *PowerOutletTemplateFeedLeg `json:"feed_leg,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// power port
	PowerPort *NestedPowerPortTemplate `json:"power_port,omitempty"`

	// type
	Type *PowerOutletTemplateType `json:"type,omitempty"`
}

PowerOutletTemplate power outlet template swagger:model PowerOutletTemplate

func (*PowerOutletTemplate) MarshalBinary 

func (m *PowerOutletTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletTemplate) UnmarshalBinary 

func (m *PowerOutletTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletTemplate) Validate 

func (m *PowerOutletTemplate) Validate(formats strfmt.Registry) error

Validate validates this power outlet template

type PowerOutletTemplateFeedLeg 

type PowerOutletTemplateFeedLeg struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerOutletTemplateFeedLeg Feed leg swagger:model PowerOutletTemplateFeedLeg

func (*PowerOutletTemplateFeedLeg) MarshalBinary 

func (m *PowerOutletTemplateFeedLeg) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletTemplateFeedLeg) UnmarshalBinary 

func (m *PowerOutletTemplateFeedLeg) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletTemplateFeedLeg) Validate 

func (m *PowerOutletTemplateFeedLeg) Validate(formats strfmt.Registry) error

Validate validates this power outlet template feed leg

type PowerOutletTemplateType 

type PowerOutletTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerOutletTemplateType Type swagger:model PowerOutletTemplateType

func (*PowerOutletTemplateType) MarshalBinary 

func (m *PowerOutletTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletTemplateType) UnmarshalBinary 

func (m *PowerOutletTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletTemplateType) Validate 

func (m *PowerOutletTemplateType) Validate(formats strfmt.Registry) error

Validate validates this power outlet template type

type PowerOutletType 

type PowerOutletType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerOutletType Type swagger:model PowerOutletType

func (*PowerOutletType) MarshalBinary 

func (m *PowerOutletType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerOutletType) UnmarshalBinary 

func (m *PowerOutletType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerOutletType) Validate 

func (m *PowerOutletType) Validate(formats strfmt.Registry) error

Validate validates this power outlet type

type PowerPanel 

type PowerPanel struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// rack group
	RackGroup *NestedRackGroup `json:"rack_group,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`
}

PowerPanel power panel swagger:model PowerPanel

func (*PowerPanel) MarshalBinary 

func (m *PowerPanel) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPanel) UnmarshalBinary 

func (m *PowerPanel) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPanel) Validate 

func (m *PowerPanel) Validate(formats strfmt.Registry) error

Validate validates this power panel

type PowerPort 

type PowerPort struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// connection status
	ConnectionStatus *PowerPortConnectionStatus `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *PowerPortType `json:"type,omitempty"`
}

PowerPort power port swagger:model PowerPort

func (*PowerPort) MarshalBinary 

func (m *PowerPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPort) UnmarshalBinary 

func (m *PowerPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPort) Validate 

func (m *PowerPort) Validate(formats strfmt.Registry) error

Validate validates this power port

type PowerPortConnectionStatus 

type PowerPortConnectionStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *bool `json:"value"`
}

PowerPortConnectionStatus Connection status swagger:model PowerPortConnectionStatus

func (*PowerPortConnectionStatus) MarshalBinary 

func (m *PowerPortConnectionStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPortConnectionStatus) UnmarshalBinary 

func (m *PowerPortConnectionStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPortConnectionStatus) Validate 

func (m *PowerPortConnectionStatus) Validate(formats strfmt.Registry) error

Validate validates this power port connection status

type PowerPortTemplate 

type PowerPortTemplate struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// type
	Type *PowerPortTemplateType `json:"type,omitempty"`
}

PowerPortTemplate power port template swagger:model PowerPortTemplate

func (*PowerPortTemplate) MarshalBinary 

func (m *PowerPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPortTemplate) UnmarshalBinary 

func (m *PowerPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPortTemplate) Validate 

func (m *PowerPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this power port template

type PowerPortTemplateType 

type PowerPortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerPortTemplateType Type swagger:model PowerPortTemplateType

func (*PowerPortTemplateType) MarshalBinary 

func (m *PowerPortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPortTemplateType) UnmarshalBinary 

func (m *PowerPortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPortTemplateType) Validate 

func (m *PowerPortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this power port template type

type PowerPortType 

type PowerPortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PowerPortType Type swagger:model PowerPortType

func (*PowerPortType) MarshalBinary 

func (m *PowerPortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PowerPortType) UnmarshalBinary 

func (m *PowerPortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PowerPortType) Validate 

func (m *PowerPortType) Validate(formats strfmt.Registry) error

Validate validates this power port type

type Prefix 

type Prefix struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// family
	Family *PrefixFamily `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is a pool
	//
	// All IP addresses within this prefix are considered usable
	IsPool bool `json:"is_pool,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Prefix
	//
	// IPv4 or IPv6 network with mask
	// Required: true
	Prefix *string `json:"prefix"`

	// role
	Role *NestedRole `json:"role,omitempty"`

	// site
	Site *NestedSite `json:"site,omitempty"`

	// status
	Status *PrefixStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// vlan
	Vlan *NestedVLAN `json:"vlan,omitempty"`

	// vrf
	Vrf *NestedVRF `json:"vrf,omitempty"`
}

Prefix prefix swagger:model Prefix

func (*Prefix) MarshalBinary 

func (m *Prefix) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Prefix) UnmarshalBinary 

func (m *Prefix) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Prefix) Validate 

func (m *Prefix) Validate(formats strfmt.Registry) error

Validate validates this prefix

type PrefixFamily 

type PrefixFamily struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PrefixFamily Family swagger:model PrefixFamily

func (*PrefixFamily) MarshalBinary 

func (m *PrefixFamily) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PrefixFamily) UnmarshalBinary 

func (m *PrefixFamily) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PrefixFamily) Validate 

func (m *PrefixFamily) Validate(formats strfmt.Registry) error

Validate validates this prefix family

type PrefixStatus 

type PrefixStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

PrefixStatus Status swagger:model PrefixStatus

func (*PrefixStatus) MarshalBinary 

func (m *PrefixStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*PrefixStatus) UnmarshalBinary 

func (m *PrefixStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*PrefixStatus) Validate 

func (m *PrefixStatus) Validate(formats strfmt.Registry) error

Validate validates this prefix status

type Provider 

type Provider struct {

	// Account number
	// Max Length: 30
	Account string `json:"account,omitempty"`

	// Admin contact
	AdminContact string `json:"admin_contact,omitempty"`

	// ASN
	// Maximum: 4.294967295e+09
	// Minimum: 1
	Asn *int64 `json:"asn,omitempty"`

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// NOC contact
	NocContact string `json:"noc_contact,omitempty"`

	// Portal
	// Max Length: 200
	// Format: uri
	PortalURL strfmt.URI `json:"portal_url,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// tags
	Tags []string `json:"tags"`
}

Provider provider swagger:model Provider

func (*Provider) MarshalBinary 

func (m *Provider) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Provider) UnmarshalBinary 

func (m *Provider) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Provider) Validate 

func (m *Provider) Validate(formats strfmt.Registry) error

Validate validates this provider

type RIR 

type RIR struct {

	// Aggregate count
	// Read Only: true
	AggregateCount int64 `json:"aggregate_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Private
	//
	// IP space managed by this RIR is considered private
	IsPrivate bool `json:"is_private,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

RIR r i r swagger:model RIR

func (*RIR) MarshalBinary 

func (m *RIR) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RIR) UnmarshalBinary 

func (m *RIR) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RIR) Validate 

func (m *RIR) Validate(formats strfmt.Registry) error

Validate validates this r i r

type Rack 

type Rack struct {

	// Asset tag
	//
	// A unique tag used to identify this rack
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Descending units
	//
	// Units are numbered top-to-bottom
	DescUnits bool `json:"desc_units,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Facility ID
	// Max Length: 50
	FacilityID *string `json:"facility_id,omitempty"`

	// group
	Group *NestedRackGroup `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Outer depth
	// Maximum: 32767
	// Minimum: 0
	OuterDepth *int64 `json:"outer_depth,omitempty"`

	// outer unit
	OuterUnit *RackOuterUnit `json:"outer_unit,omitempty"`

	// Outer width
	// Maximum: 32767
	// Minimum: 0
	OuterWidth *int64 `json:"outer_width,omitempty"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// role
	Role *NestedRackRole `json:"role,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// status
	Status *RackStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// type
	Type *RackType `json:"type,omitempty"`

	// Height (U)
	// Maximum: 100
	// Minimum: 1
	UHeight int64 `json:"u_height,omitempty"`

	// width
	Width *RackWidth `json:"width,omitempty"`
}

Rack rack swagger:model Rack

func (*Rack) MarshalBinary 

func (m *Rack) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Rack) UnmarshalBinary 

func (m *Rack) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Rack) Validate 

func (m *Rack) Validate(formats strfmt.Registry) error

Validate validates this rack

type RackGroup 

type RackGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// site
	// Required: true
	Site *NestedSite `json:"site"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

RackGroup rack group swagger:model RackGroup

func (*RackGroup) MarshalBinary 

func (m *RackGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackGroup) UnmarshalBinary 

func (m *RackGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackGroup) Validate 

func (m *RackGroup) Validate(formats strfmt.Registry) error

Validate validates this rack group

type RackOuterUnit 

type RackOuterUnit struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackOuterUnit Outer unit swagger:model RackOuterUnit

func (*RackOuterUnit) MarshalBinary 

func (m *RackOuterUnit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackOuterUnit) UnmarshalBinary 

func (m *RackOuterUnit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackOuterUnit) Validate 

func (m *RackOuterUnit) Validate(formats strfmt.Registry) error

Validate validates this rack outer unit

type RackReservation 

type RackReservation struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Description
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Description *string `json:"description"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// rack
	// Required: true
	Rack *NestedRack `json:"rack"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// units
	// Required: true
	Units []*int64 `json:"units"`

	// user
	// Required: true
	User *NestedUser `json:"user"`
}

RackReservation rack reservation swagger:model RackReservation

func (*RackReservation) MarshalBinary 

func (m *RackReservation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackReservation) UnmarshalBinary 

func (m *RackReservation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackReservation) Validate 

func (m *RackReservation) Validate(formats strfmt.Registry) error

Validate validates this rack reservation

type RackRole 

type RackRole struct {

	// Color
	// Required: true
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color *string `json:"color"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

RackRole rack role swagger:model RackRole

func (*RackRole) MarshalBinary 

func (m *RackRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackRole) UnmarshalBinary 

func (m *RackRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackRole) Validate 

func (m *RackRole) Validate(formats strfmt.Registry) error

Validate validates this rack role

type RackStatus 

type RackStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackStatus Status swagger:model RackStatus

func (*RackStatus) MarshalBinary 

func (m *RackStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackStatus) UnmarshalBinary 

func (m *RackStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackStatus) Validate 

func (m *RackStatus) Validate(formats strfmt.Registry) error

Validate validates this rack status

type RackType 

type RackType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackType Type swagger:model RackType

func (*RackType) MarshalBinary 

func (m *RackType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackType) UnmarshalBinary 

func (m *RackType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackType) Validate 

func (m *RackType) Validate(formats strfmt.Registry) error

Validate validates this rack type

type RackUnit 

type RackUnit struct {

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// face
	Face *RackUnitFace `json:"face,omitempty"`

	// Id
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Read Only: true
	// Min Length: 1
	Name string `json:"name,omitempty"`
}

RackUnit rack unit swagger:model RackUnit

func (*RackUnit) MarshalBinary 

func (m *RackUnit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackUnit) UnmarshalBinary 

func (m *RackUnit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackUnit) Validate 

func (m *RackUnit) Validate(formats strfmt.Registry) error

Validate validates this rack unit

type RackUnitFace 

type RackUnitFace struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackUnitFace Face swagger:model RackUnitFace

func (*RackUnitFace) MarshalBinary 

func (m *RackUnitFace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackUnitFace) UnmarshalBinary 

func (m *RackUnitFace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackUnitFace) Validate 

func (m *RackUnitFace) Validate(formats strfmt.Registry) error

Validate validates this rack unit face

type RackWidth 

type RackWidth struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackWidth Width swagger:model RackWidth

func (*RackWidth) MarshalBinary 

func (m *RackWidth) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackWidth) UnmarshalBinary 

func (m *RackWidth) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackWidth) Validate 

func (m *RackWidth) Validate(formats strfmt.Registry) error

Validate validates this rack width

type RearPort 

type RearPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// type
	// Required: true
	Type *RearPortType `json:"type"`
}

RearPort rear port swagger:model RearPort

func (*RearPort) MarshalBinary 

func (m *RearPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPort) UnmarshalBinary 

func (m *RearPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPort) Validate 

func (m *RearPort) Validate(formats strfmt.Registry) error

Validate validates this rear port

type RearPortTemplate 

type RearPortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// type
	// Required: true
	Type *RearPortTemplateType `json:"type"`
}

RearPortTemplate rear port template swagger:model RearPortTemplate

func (*RearPortTemplate) MarshalBinary 

func (m *RearPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortTemplate) UnmarshalBinary 

func (m *RearPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortTemplate) Validate 

func (m *RearPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this rear port template

type RearPortTemplateType 

type RearPortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RearPortTemplateType Type swagger:model RearPortTemplateType

func (*RearPortTemplateType) MarshalBinary 

func (m *RearPortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortTemplateType) UnmarshalBinary 

func (m *RearPortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortTemplateType) Validate 

func (m *RearPortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this rear port template type

type RearPortType 

type RearPortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RearPortType Type swagger:model RearPortType

func (*RearPortType) MarshalBinary 

func (m *RearPortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortType) UnmarshalBinary 

func (m *RearPortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortType) Validate 

func (m *RearPortType) Validate(formats strfmt.Registry) error

Validate validates this rear port type

type Region 

type Region struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// parent
	Parent *NestedRegion `json:"parent,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

Region region swagger:model Region

func (*Region) MarshalBinary 

func (m *Region) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Region) UnmarshalBinary 

func (m *Region) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Region) Validate 

func (m *Region) Validate(formats strfmt.Registry) error

Validate validates this region

type Role 

type Role struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

Role role swagger:model Role

func (*Role) MarshalBinary 

func (m *Role) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Role) UnmarshalBinary 

func (m *Role) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Role) Validate 

func (m *Role) Validate(formats strfmt.Registry) error

Validate validates this role

type Secret 

type Secret struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Hash
	// Read Only: true
	// Min Length: 1
	Hash string `json:"hash,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Max Length: 100
	Name string `json:"name,omitempty"`

	// Plaintext
	// Required: true
	// Min Length: 1
	Plaintext *string `json:"plaintext"`

	// role
	// Required: true
	Role *NestedSecretRole `json:"role"`

	// tags
	Tags []string `json:"tags"`
}

Secret secret swagger:model Secret

func (*Secret) MarshalBinary 

func (m *Secret) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Secret) UnmarshalBinary 

func (m *Secret) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Secret) Validate 

func (m *Secret) Validate(formats strfmt.Registry) error

Validate validates this secret

type SecretRole 

type SecretRole struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Secret count
	// Read Only: true
	SecretCount int64 `json:"secret_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

SecretRole secret role swagger:model SecretRole

func (*SecretRole) MarshalBinary 

func (m *SecretRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SecretRole) UnmarshalBinary 

func (m *SecretRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SecretRole) Validate 

func (m *SecretRole) Validate(formats strfmt.Registry) error

Validate validates this secret role

type Service 

type Service struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// ipaddresses
	// Unique: true
	Ipaddresses []*NestedIPAddress `json:"ipaddresses"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Port number
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	Port *int64 `json:"port"`

	// protocol
	Protocol *ServiceProtocol `json:"protocol,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// virtual machine
	VirtualMachine *NestedVirtualMachine `json:"virtual_machine,omitempty"`
}

Service service swagger:model Service

func (*Service) MarshalBinary 

func (m *Service) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Service) UnmarshalBinary 

func (m *Service) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Service) Validate 

func (m *Service) Validate(formats strfmt.Registry) error

Validate validates this service

type ServiceProtocol 

type ServiceProtocol struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ServiceProtocol Protocol swagger:model ServiceProtocol

func (*ServiceProtocol) MarshalBinary 

func (m *ServiceProtocol) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServiceProtocol) UnmarshalBinary 

func (m *ServiceProtocol) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServiceProtocol) Validate 

func (m *ServiceProtocol) Validate(formats strfmt.Registry) error

Validate validates this service protocol

type Site 

type Site struct {

	// ASN
	// Maximum: 4.294967295e+09
	// Minimum: 1
	Asn *int64 `json:"asn,omitempty"`

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Contact E-mail
	// Max Length: 254
	// Format: email
	ContactEmail strfmt.Email `json:"contact_email,omitempty"`

	// Contact name
	// Max Length: 50
	ContactName string `json:"contact_name,omitempty"`

	// Contact phone
	// Max Length: 20
	ContactPhone string `json:"contact_phone,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Facility
	// Max Length: 50
	Facility string `json:"facility,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Latitude
	Latitude *string `json:"latitude,omitempty"`

	// Longitude
	Longitude *string `json:"longitude,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Physical address
	// Max Length: 200
	PhysicalAddress string `json:"physical_address,omitempty"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// region
	Region *NestedRegion `json:"region,omitempty"`

	// Shipping address
	// Max Length: 200
	ShippingAddress string `json:"shipping_address,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// status
	Status *SiteStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// Time zone
	TimeZone string `json:"time_zone,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

Site site swagger:model Site

func (*Site) MarshalBinary 

func (m *Site) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Site) UnmarshalBinary 

func (m *Site) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Site) Validate 

func (m *Site) Validate(formats strfmt.Registry) error

Validate validates this site

type SiteStatus 

type SiteStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

SiteStatus Status swagger:model SiteStatus

func (*SiteStatus) MarshalBinary 

func (m *SiteStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SiteStatus) UnmarshalBinary 

func (m *SiteStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SiteStatus) Validate 

func (m *SiteStatus) Validate(formats strfmt.Registry) error

Validate validates this site status

type Tag 

type Tag struct {

	// Color
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color string `json:"color,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 100
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Tagged items
	// Read Only: true
	TaggedItems int64 `json:"tagged_items,omitempty"`
}

Tag tag swagger:model Tag

func (*Tag) MarshalBinary 

func (m *Tag) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Tag) UnmarshalBinary 

func (m *Tag) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Tag) Validate 

func (m *Tag) Validate(formats strfmt.Registry) error

Validate validates this tag

type Tenant 

type Tenant struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	//
	// Long-form name (optional)
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// group
	Group *NestedTenantGroup `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Ipaddress count
	// Read Only: true
	IpaddressCount int64 `json:"ipaddress_count,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// tags
	Tags []string `json:"tags"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`

	// Vrf count
	// Read Only: true
	VrfCount int64 `json:"vrf_count,omitempty"`
}

Tenant tenant swagger:model Tenant

func (*Tenant) MarshalBinary 

func (m *Tenant) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Tenant) UnmarshalBinary 

func (m *Tenant) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Tenant) Validate 

func (m *Tenant) Validate(formats strfmt.Registry) error

Validate validates this tenant

type TenantGroup 

type TenantGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Tenant count
	// Read Only: true
	TenantCount int64 `json:"tenant_count,omitempty"`
}

TenantGroup tenant group swagger:model TenantGroup

func (*TenantGroup) MarshalBinary 

func (m *TenantGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*TenantGroup) UnmarshalBinary 

func (m *TenantGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*TenantGroup) Validate 

func (m *TenantGroup) Validate(formats strfmt.Registry) error

Validate validates this tenant group

type VLAN 

type VLAN struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// group
	Group *NestedVLANGroup `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// role
	Role *NestedRole `json:"role,omitempty"`

	// site
	Site *NestedSite `json:"site,omitempty"`

	// status
	Status *VLANStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// ID
	// Required: true
	// Maximum: 4094
	// Minimum: 1
	Vid *int64 `json:"vid"`
}

VLAN v l a n swagger:model VLAN

func (*VLAN) MarshalBinary 

func (m *VLAN) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VLAN) UnmarshalBinary 

func (m *VLAN) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VLAN) Validate 

func (m *VLAN) Validate(formats strfmt.Registry) error

Validate validates this v l a n

type VLANGroup 

type VLANGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// site
	Site *NestedSite `json:"site,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

VLANGroup v l a n group swagger:model VLANGroup

func (*VLANGroup) MarshalBinary 

func (m *VLANGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VLANGroup) UnmarshalBinary 

func (m *VLANGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VLANGroup) Validate 

func (m *VLANGroup) Validate(formats strfmt.Registry) error

Validate validates this v l a n group

type VLANStatus 

type VLANStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

VLANStatus Status swagger:model VLANStatus

func (*VLANStatus) MarshalBinary 

func (m *VLANStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VLANStatus) UnmarshalBinary 

func (m *VLANStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VLANStatus) Validate 

func (m *VLANStatus) Validate(formats strfmt.Registry) error

Validate validates this v l a n status

type VRF 

type VRF struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Enforce unique space
	//
	// Prevent duplicate prefixes/IP addresses within this VRF
	EnforceUnique bool `json:"enforce_unique,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Ipaddress count
	// Read Only: true
	IpaddressCount int64 `json:"ipaddress_count,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Route distinguisher
	// Max Length: 21
	Rd *string `json:"rd,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`
}

VRF v r f swagger:model VRF

func (*VRF) MarshalBinary 

func (m *VRF) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VRF) UnmarshalBinary 

func (m *VRF) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VRF) Validate 

func (m *VRF) Validate(formats strfmt.Registry) error

Validate validates this v r f

type VirtualChassis 

type VirtualChassis struct {

	// Domain
	// Max Length: 30
	Domain string `json:"domain,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// master
	// Required: true
	Master *NestedDevice `json:"master"`

	// Member count
	// Read Only: true
	MemberCount int64 `json:"member_count,omitempty"`

	// tags
	Tags []string `json:"tags"`
}

VirtualChassis virtual chassis swagger:model VirtualChassis

func (*VirtualChassis) MarshalBinary 

func (m *VirtualChassis) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualChassis) UnmarshalBinary 

func (m *VirtualChassis) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualChassis) Validate 

func (m *VirtualChassis) Validate(formats strfmt.Registry) error

Validate validates this virtual chassis

type VirtualMachineInterface 

type VirtualMachineInterface struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Enabled
	Enabled bool `json:"enabled,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// MAC Address
	MacAddress *string `json:"mac_address,omitempty"`

	// mode
	Mode *VirtualMachineInterfaceMode `json:"mode,omitempty"`

	// MTU
	// Maximum: 65536
	// Minimum: 1
	Mtu *int64 `json:"mtu,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// tagged vlans
	// Unique: true
	TaggedVlans []*NestedVLAN `json:"tagged_vlans"`

	// tags
	Tags []string `json:"tags"`

	// type
	Type *VirtualMachineInterfaceType `json:"type,omitempty"`

	// untagged vlan
	UntaggedVlan *NestedVLAN `json:"untagged_vlan,omitempty"`

	// virtual machine
	// Required: true
	VirtualMachine *NestedVirtualMachine `json:"virtual_machine"`
}

VirtualMachineInterface virtual machine interface swagger:model VirtualMachineInterface

func (*VirtualMachineInterface) MarshalBinary 

func (m *VirtualMachineInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualMachineInterface) UnmarshalBinary 

func (m *VirtualMachineInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualMachineInterface) Validate 

func (m *VirtualMachineInterface) Validate(formats strfmt.Registry) error

Validate validates this virtual machine interface

type VirtualMachineInterfaceMode 

type VirtualMachineInterfaceMode struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

VirtualMachineInterfaceMode Mode swagger:model VirtualMachineInterfaceMode

func (*VirtualMachineInterfaceMode) MarshalBinary 

func (m *VirtualMachineInterfaceMode) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualMachineInterfaceMode) UnmarshalBinary 

func (m *VirtualMachineInterfaceMode) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualMachineInterfaceMode) Validate 

func (m *VirtualMachineInterfaceMode) Validate(formats strfmt.Registry) error

Validate validates this virtual machine interface mode

type VirtualMachineInterfaceType 

type VirtualMachineInterfaceType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

VirtualMachineInterfaceType Type swagger:model VirtualMachineInterfaceType

func (*VirtualMachineInterfaceType) MarshalBinary 

func (m *VirtualMachineInterfaceType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualMachineInterfaceType) UnmarshalBinary 

func (m *VirtualMachineInterfaceType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualMachineInterfaceType) UnmarshalJSON 

func (m *VirtualMachineInterfaceType) UnmarshalJSON(b []byte) error

func (*VirtualMachineInterfaceType) Validate 

func (m *VirtualMachineInterfaceType) Validate(formats strfmt.Registry) error

Validate validates this virtual machine interface type

type VirtualMachineWithConfigContext 

type VirtualMachineWithConfigContext struct {

	// cluster
	// Required: true
	Cluster *NestedCluster `json:"cluster"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Config context
	// Read Only: true
	ConfigContext map[string]string `json:"config_context,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Disk (GB)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	Disk *int64 `json:"disk,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Memory (MB)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	Memory *int64 `json:"memory,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// platform
	Platform *NestedPlatform `json:"platform,omitempty"`

	// primary ip
	PrimaryIP *NestedIPAddress `json:"primary_ip,omitempty"`

	// primary ip4
	PrimaryIp4 *NestedIPAddress `json:"primary_ip4,omitempty"`

	// primary ip6
	PrimaryIp6 *NestedIPAddress `json:"primary_ip6,omitempty"`

	// role
	Role *NestedDeviceRole `json:"role,omitempty"`

	// site
	Site *NestedSite `json:"site,omitempty"`

	// status
	Status *VirtualMachineWithConfigContextStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// VCPUs
	// Maximum: 32767
	// Minimum: 0
	Vcpus *int64 `json:"vcpus,omitempty"`
}

VirtualMachineWithConfigContext virtual machine with config context swagger:model VirtualMachineWithConfigContext

func (*VirtualMachineWithConfigContext) MarshalBinary 

func (m *VirtualMachineWithConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualMachineWithConfigContext) UnmarshalBinary 

func (m *VirtualMachineWithConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualMachineWithConfigContext) Validate 

func (m *VirtualMachineWithConfigContext) Validate(formats strfmt.Registry) error

Validate validates this virtual machine with config context

type VirtualMachineWithConfigContextStatus 

type VirtualMachineWithConfigContextStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

VirtualMachineWithConfigContextStatus Status swagger:model VirtualMachineWithConfigContextStatus

func (*VirtualMachineWithConfigContextStatus) MarshalBinary 

func (m *VirtualMachineWithConfigContextStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*VirtualMachineWithConfigContextStatus) UnmarshalBinary 

func (m *VirtualMachineWithConfigContextStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*VirtualMachineWithConfigContextStatus) Validate 

func (m *VirtualMachineWithConfigContextStatus) Validate(formats strfmt.Registry) error

Validate validates this virtual machine with config context status

type WritableAggregate 

type WritableAggregate struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Date added
	// Format: date
	DateAdded *strfmt.Date `json:"date_added,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Family
	// Read Only: true
	// Enum: [4 6]
	Family int64 `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Prefix
	// Required: true
	Prefix *string `json:"prefix"`

	// RIR
	// Required: true
	Rir *int64 `json:"rir"`

	// tags
	Tags []string `json:"tags"`
}

WritableAggregate writable aggregate swagger:model WritableAggregate

func (*WritableAggregate) MarshalBinary 

func (m *WritableAggregate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableAggregate) UnmarshalBinary 

func (m *WritableAggregate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableAggregate) Validate 

func (m *WritableAggregate) Validate(formats strfmt.Registry) error

Validate validates this writable aggregate

type WritableAvailableIPAddress 

type WritableAvailableIPAddress struct {
	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// DNS Name
	//
	// Hostname or FQDN (not case-sensitive)
	// Max Length: 255
	// Pattern: ^[0-9A-Za-z.-]+$
	DNSName string `json:"dns_name,omitempty"`

	// Family
	// Read Only: true
	Family int64 `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Interface
	Interface *int64 `json:"interface,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// NAT (Inside)
	//
	// The IP for which this address is the "outside" IP
	NatInside *int64 `json:"nat_inside,omitempty"`

	// Nat outside
	// Required: true
	NatOutside *int64 `json:"nat_outside"`

	// Role
	//
	// The functional role of this IP
	// Enum: [loopback secondary anycast vip vrrp hsrp glbp carp]
	Role string `json:"role,omitempty"`

	// Status
	//
	// The operational status of this IP
	// Enum: [active reserved deprecated dhcp]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// VRF
	Vrf *int64 `json:"vrf,omitempty"`
}

WritableAvailableIPAddress writable IP address swagger:model WritableAvailableIPAddress

func (*WritableAvailableIPAddress) MarshalBinary 

func (m *WritableAvailableIPAddress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableAvailableIPAddress) UnmarshalBinary 

func (m *WritableAvailableIPAddress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableAvailableIPAddress) Validate 

func (m *WritableAvailableIPAddress) Validate(formats strfmt.Registry) error

Validate validates this writable IP address

type WritableCable 

type WritableCable struct {

	// Color
	// Max Length: 6
	// Pattern: ^[0-9a-f]{6}$
	Color string `json:"color,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Label
	// Max Length: 100
	Label string `json:"label,omitempty"`

	// Length
	// Maximum: 32767
	// Minimum: 0
	Length *int64 `json:"length,omitempty"`

	// Length unit
	// Enum: [m cm ft in]
	LengthUnit string `json:"length_unit,omitempty"`

	// Status
	// Enum: [connected planned decommissioning]
	Status string `json:"status,omitempty"`

	// Termination a
	// Read Only: true
	Terminationa map[string]string `json:"termination_a,omitempty"`

	// Termination a id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	TerminationaID *int64 `json:"termination_a_id"`

	// Termination a type
	// Required: true
	TerminationaType *string `json:"termination_a_type"`

	// Termination b
	// Read Only: true
	Terminationb map[string]string `json:"termination_b,omitempty"`

	// Termination b id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	TerminationbID *int64 `json:"termination_b_id"`

	// Termination b type
	// Required: true
	TerminationbType *string `json:"termination_b_type"`

	// Type
	// Enum: [cat3 cat5 cat5e cat6 cat6a cat7 dac-active dac-passive coaxial mmf mmf-om1 mmf-om2 mmf-om3 mmf-om4 smf smf-os1 smf-os2 aoc power]
	Type string `json:"type,omitempty"`
}

WritableCable writable cable swagger:model WritableCable

func (*WritableCable) MarshalBinary 

func (m *WritableCable) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableCable) UnmarshalBinary 

func (m *WritableCable) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableCable) Validate 

func (m *WritableCable) Validate(formats strfmt.Registry) error

Validate validates this writable cable

type WritableCircuit 

type WritableCircuit struct {

	// Circuit ID
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Cid *string `json:"cid"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Commit rate (Kbps)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	CommitRate *int64 `json:"commit_rate,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Date installed
	// Format: date
	InstallDate *strfmt.Date `json:"install_date,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Provider
	// Required: true
	Provider *int64 `json:"provider"`

	// Status
	// Enum: [planned provisioning active offline deprovisioning decommissioned]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// Termination a
	// Read Only: true
	Terminationa string `json:"termination_a,omitempty"`

	// Termination z
	// Read Only: true
	Terminationz string `json:"termination_z,omitempty"`

	// Type
	// Required: true
	Type *int64 `json:"type"`
}

WritableCircuit writable circuit swagger:model WritableCircuit

func (*WritableCircuit) MarshalBinary 

func (m *WritableCircuit) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableCircuit) UnmarshalBinary 

func (m *WritableCircuit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableCircuit) Validate 

func (m *WritableCircuit) Validate(formats strfmt.Registry) error

Validate validates this writable circuit

type WritableCircuitTermination 

type WritableCircuitTermination struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Circuit
	// Required: true
	Circuit *int64 `json:"circuit"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Port speed (Kbps)
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	PortSpeed *int64 `json:"port_speed"`

	// Patch panel/port(s)
	// Max Length: 100
	PpInfo string `json:"pp_info,omitempty"`

	// Site
	// Required: true
	Site *int64 `json:"site"`

	// Termination
	// Required: true
	// Enum: [A Z]
	TermSide *string `json:"term_side"`

	// Upstream speed (Kbps)
	//
	// Upstream speed, if different from port speed
	// Maximum: 2.147483647e+09
	// Minimum: 0
	UpstreamSpeed *int64 `json:"upstream_speed,omitempty"`

	// Cross-connect ID
	// Max Length: 50
	XconnectID string `json:"xconnect_id,omitempty"`
}

WritableCircuitTermination writable circuit termination swagger:model WritableCircuitTermination

func (*WritableCircuitTermination) MarshalBinary 

func (m *WritableCircuitTermination) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableCircuitTermination) UnmarshalBinary 

func (m *WritableCircuitTermination) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableCircuitTermination) Validate 

func (m *WritableCircuitTermination) Validate(formats strfmt.Registry) error

Validate validates this writable circuit termination

type WritableCluster 

type WritableCluster struct {

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Group
	Group *int64 `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Site
	Site *int64 `json:"site,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// Type
	// Required: true
	Type *int64 `json:"type"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

WritableCluster writable cluster swagger:model WritableCluster

func (*WritableCluster) MarshalBinary 

func (m *WritableCluster) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableCluster) UnmarshalBinary 

func (m *WritableCluster) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableCluster) Validate 

func (m *WritableCluster) Validate(formats strfmt.Registry) error

Validate validates this writable cluster

type WritableConfigContext 

type WritableConfigContext struct {

	// cluster groups
	// Unique: true
	ClusterGroups []int64 `json:"cluster_groups"`

	// clusters
	// Unique: true
	Clusters []int64 `json:"clusters"`

	// Data
	// Required: true
	Data *string `json:"data"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is active
	IsActive bool `json:"is_active,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// platforms
	// Unique: true
	Platforms []int64 `json:"platforms"`

	// regions
	// Unique: true
	Regions []int64 `json:"regions"`

	// roles
	// Unique: true
	Roles []int64 `json:"roles"`

	// sites
	// Unique: true
	Sites []int64 `json:"sites"`

	// tags
	// Unique: true
	Tags []string `json:"tags"`

	// tenant groups
	// Unique: true
	TenantGroups []int64 `json:"tenant_groups"`

	// tenants
	// Unique: true
	Tenants []int64 `json:"tenants"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

WritableConfigContext writable config context swagger:model WritableConfigContext

func (*WritableConfigContext) MarshalBinary 

func (m *WritableConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableConfigContext) UnmarshalBinary 

func (m *WritableConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableConfigContext) Validate 

func (m *WritableConfigContext) Validate(formats strfmt.Registry) error

Validate validates this writable config context

type WritableConsolePort 

type WritableConsolePort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Enum: [de-9 db-25 rj-11 rj-12 rj-45 usb-a usb-b usb-c usb-mini-a usb-mini-b usb-micro-a usb-micro-b other]
	Type string `json:"type,omitempty"`
}

WritableConsolePort writable console port swagger:model WritableConsolePort

func (*WritableConsolePort) MarshalBinary 

func (m *WritableConsolePort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableConsolePort) UnmarshalBinary 

func (m *WritableConsolePort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableConsolePort) Validate 

func (m *WritableConsolePort) Validate(formats strfmt.Registry) error

Validate validates this writable console port

type WritableConsolePortTemplate 

type WritableConsolePortTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Type
	// Enum: [de-9 db-25 rj-11 rj-12 rj-45 usb-a usb-b usb-c usb-mini-a usb-mini-b usb-micro-a usb-micro-b other]
	Type string `json:"type,omitempty"`
}

WritableConsolePortTemplate writable console port template swagger:model WritableConsolePortTemplate

func (*WritableConsolePortTemplate) MarshalBinary 

func (m *WritableConsolePortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableConsolePortTemplate) UnmarshalBinary 

func (m *WritableConsolePortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableConsolePortTemplate) Validate 

func (m *WritableConsolePortTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable console port template

type WritableConsoleServerPort 

type WritableConsoleServerPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Enum: [de-9 db-25 rj-11 rj-12 rj-45 usb-a usb-b usb-c usb-mini-a usb-mini-b usb-micro-a usb-micro-b other]
	Type string `json:"type,omitempty"`
}

WritableConsoleServerPort writable console server port swagger:model WritableConsoleServerPort

func (*WritableConsoleServerPort) MarshalBinary 

func (m *WritableConsoleServerPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableConsoleServerPort) UnmarshalBinary 

func (m *WritableConsoleServerPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableConsoleServerPort) Validate 

func (m *WritableConsoleServerPort) Validate(formats strfmt.Registry) error

Validate validates this writable console server port

type WritableConsoleServerPortTemplate 

type WritableConsoleServerPortTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Type
	// Enum: [de-9 db-25 rj-11 rj-12 rj-45 usb-a usb-b usb-c usb-mini-a usb-mini-b usb-micro-a usb-micro-b other]
	Type string `json:"type,omitempty"`
}

WritableConsoleServerPortTemplate writable console server port template swagger:model WritableConsoleServerPortTemplate

func (*WritableConsoleServerPortTemplate) MarshalBinary 

func (m *WritableConsoleServerPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableConsoleServerPortTemplate) UnmarshalBinary 

func (m *WritableConsoleServerPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableConsoleServerPortTemplate) Validate 

func (m *WritableConsoleServerPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable console server port template

type WritableDeviceBay 

type WritableDeviceBay struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Installed device
	InstalledDevice *int64 `json:"installed_device,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`
}

WritableDeviceBay writable device bay swagger:model WritableDeviceBay

func (*WritableDeviceBay) MarshalBinary 

func (m *WritableDeviceBay) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableDeviceBay) UnmarshalBinary 

func (m *WritableDeviceBay) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableDeviceBay) Validate 

func (m *WritableDeviceBay) Validate(formats strfmt.Registry) error

Validate validates this writable device bay

type WritableDeviceBayTemplate 

type WritableDeviceBayTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`
}

WritableDeviceBayTemplate writable device bay template swagger:model WritableDeviceBayTemplate

func (*WritableDeviceBayTemplate) MarshalBinary 

func (m *WritableDeviceBayTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableDeviceBayTemplate) UnmarshalBinary 

func (m *WritableDeviceBayTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableDeviceBayTemplate) Validate 

func (m *WritableDeviceBayTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable device bay template

type WritableDeviceInterface 

type WritableDeviceInterface struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Count ipaddresses
	// Read Only: true
	CountIpaddresses string `json:"count_ipaddresses,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// Enabled
	Enabled bool `json:"enabled,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Parent LAG
	Lag *int64 `json:"lag,omitempty"`

	// MAC Address
	MacAddress *string `json:"mac_address,omitempty"`

	// OOB Management
	//
	// This interface is used only for out-of-band management
	MgmtOnly bool `json:"mgmt_only,omitempty"`

	// Mode
	// Enum: [access tagged tagged-all]
	Mode string `json:"mode,omitempty"`

	// MTU
	// Maximum: 65536
	// Minimum: 1
	Mtu *int64 `json:"mtu,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// tagged vlans
	// Unique: true
	TaggedVlans []int64 `json:"tagged_vlans"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Required: true
	// Enum: [virtual lag 100base-tx 1000base-t 2.5gbase-t 5gbase-t 10gbase-t 10gbase-cx4 1000base-x-gbic 1000base-x-sfp 10gbase-x-sfpp 10gbase-x-xfp 10gbase-x-xenpak 10gbase-x-x2 25gbase-x-sfp28 40gbase-x-qsfpp 50gbase-x-sfp28 100gbase-x-cfp 100gbase-x-cfp2 200gbase-x-cfp2 100gbase-x-cfp4 100gbase-x-cpak 100gbase-x-qsfp28 200gbase-x-qsfp56 400gbase-x-qsfpdd 400gbase-x-osfp ieee802.11a ieee802.11g ieee802.11n ieee802.11ac ieee802.11ad ieee802.11ax gsm cdma lte sonet-oc3 sonet-oc12 sonet-oc48 sonet-oc192 sonet-oc768 sonet-oc1920 sonet-oc3840 1gfc-sfp 2gfc-sfp 4gfc-sfp 8gfc-sfpp 16gfc-sfpp 32gfc-sfp28 128gfc-sfp28 inifiband-sdr inifiband-ddr inifiband-qdr inifiband-fdr10 inifiband-fdr inifiband-edr inifiband-hdr inifiband-ndr inifiband-xdr t1 e1 t3 e3 cisco-stackwise cisco-stackwise-plus cisco-flexstack cisco-flexstack-plus juniper-vcp extreme-summitstack extreme-summitstack-128 extreme-summitstack-256 extreme-summitstack-512 other]
	Type *string `json:"type"`

	// Untagged VLAN
	UntaggedVlan *int64 `json:"untagged_vlan,omitempty"`
}

WritableDeviceInterface writable device interface swagger:model WritableDeviceInterface

func (*WritableDeviceInterface) MarshalBinary 

func (m *WritableDeviceInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableDeviceInterface) UnmarshalBinary 

func (m *WritableDeviceInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableDeviceInterface) Validate 

func (m *WritableDeviceInterface) Validate(formats strfmt.Registry) error

Validate validates this writable device interface

type WritableDeviceType 

type WritableDeviceType struct {

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Front image
	// Read Only: true
	// Format: uri
	FrontImage strfmt.URI `json:"front_image,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is full depth
	//
	// Device consumes both front and rear rack faces
	IsFullDepth bool `json:"is_full_depth,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Manufacturer
	// Required: true
	Manufacturer *int64 `json:"manufacturer"`

	// Model
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Model *string `json:"model"`

	// Part number
	//
	// Discrete part number (optional)
	// Max Length: 50
	PartNumber string `json:"part_number,omitempty"`

	// Rear image
	// Read Only: true
	// Format: uri
	RearImage strfmt.URI `json:"rear_image,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Parent/child status
	//
	// Parent devices house child devices in device bays. Leave blank if this device type is neither a parent nor a child.
	// Enum: [parent child]
	SubdeviceRole string `json:"subdevice_role,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Height (U)
	// Maximum: 32767
	// Minimum: 0
	UHeight *int64 `json:"u_height,omitempty"`
}

WritableDeviceType writable device type swagger:model WritableDeviceType

func (*WritableDeviceType) MarshalBinary 

func (m *WritableDeviceType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableDeviceType) UnmarshalBinary 

func (m *WritableDeviceType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableDeviceType) Validate 

func (m *WritableDeviceType) Validate(formats strfmt.Registry) error

Validate validates this writable device type

type WritableDeviceWithConfigContext 

type WritableDeviceWithConfigContext struct {

	// Asset tag
	//
	// A unique tag used to identify this device
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// Cluster
	Cluster *int64 `json:"cluster,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Config context
	// Read Only: true
	ConfigContext map[string]string `json:"config_context,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device role
	// Required: true
	DeviceRole *int64 `json:"device_role"`

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Rack face
	// Enum: [front rear]
	Face string `json:"face,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

	// parent device
	ParentDevice *NestedDevice `json:"parent_device,omitempty"`

	// Platform
	Platform *int64 `json:"platform,omitempty"`

	// Position (U)
	//
	// The lowest-numbered unit occupied by the device
	// Maximum: 32767
	// Minimum: 1
	Position *int64 `json:"position,omitempty"`

	// Primary ip
	// Read Only: true
	PrimaryIP string `json:"primary_ip,omitempty"`

	// Primary IPv4
	PrimaryIp4 *int64 `json:"primary_ip4,omitempty"`

	// Primary IPv6
	PrimaryIp6 *int64 `json:"primary_ip6,omitempty"`

	// Rack
	Rack *int64 `json:"rack,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// Site
	// Required: true
	Site *int64 `json:"site"`

	// Status
	// Enum: [offline active planned staged failed inventory decommissioning]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// Vc position
	// Maximum: 255
	// Minimum: 0
	VcPosition *int64 `json:"vc_position,omitempty"`

	// Vc priority
	// Maximum: 255
	// Minimum: 0
	VcPriority *int64 `json:"vc_priority,omitempty"`

	// Virtual chassis
	VirtualChassis *int64 `json:"virtual_chassis,omitempty"`
}

WritableDeviceWithConfigContext writable device with config context swagger:model WritableDeviceWithConfigContext

func (*WritableDeviceWithConfigContext) MarshalBinary 

func (m *WritableDeviceWithConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableDeviceWithConfigContext) UnmarshalBinary 

func (m *WritableDeviceWithConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableDeviceWithConfigContext) Validate 

func (m *WritableDeviceWithConfigContext) Validate(formats strfmt.Registry) error

Validate validates this writable device with config context

type WritableExportTemplate 

type WritableExportTemplate struct {

	// Content type
	// Required: true
	ContentType *string `json:"content_type"`

	// Description
	// Max Length: 200
	Description string `json:"description,omitempty"`

	// File extension
	//
	// Extension to append to the rendered filename
	// Max Length: 15
	FileExtension string `json:"file_extension,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// MIME type
	//
	// Defaults to <code>text/plain</code>
	// Max Length: 50
	MimeType string `json:"mime_type,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Template code
	//
	// The list of objects being exported is passed as a context variable named <code>queryset</code>.
	// Required: true
	// Min Length: 1
	TemplateCode *string `json:"template_code"`

	// Template language
	// Enum: [django jinja2]
	TemplateLanguage string `json:"template_language,omitempty"`
}

WritableExportTemplate writable export template swagger:model WritableExportTemplate

func (*WritableExportTemplate) MarshalBinary 

func (m *WritableExportTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableExportTemplate) UnmarshalBinary 

func (m *WritableExportTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableExportTemplate) Validate 

func (m *WritableExportTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable export template

type WritableFrontPort 

type WritableFrontPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Rear port
	// Required: true
	RearPort *int64 `json:"rear_port"`

	// Rear port position
	// Maximum: 64
	// Minimum: 1
	RearPortPosition int64 `json:"rear_port_position,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Required: true
	// Enum: [8p8c 110-punch bnc fc lc lc-apc lsh lsh-apc mpo mtrj sc sc-apc st]
	Type *string `json:"type"`
}

WritableFrontPort writable front port swagger:model WritableFrontPort

func (*WritableFrontPort) MarshalBinary 

func (m *WritableFrontPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableFrontPort) UnmarshalBinary 

func (m *WritableFrontPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableFrontPort) Validate 

func (m *WritableFrontPort) Validate(formats strfmt.Registry) error

Validate validates this writable front port

type WritableFrontPortTemplate 

type WritableFrontPortTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Rear port
	// Required: true
	RearPort *int64 `json:"rear_port"`

	// Rear port position
	// Maximum: 64
	// Minimum: 1
	RearPortPosition int64 `json:"rear_port_position,omitempty"`

	// Type
	// Required: true
	// Enum: [8p8c 110-punch bnc fc lc lc-apc lsh lsh-apc mpo mtrj sc sc-apc st]
	Type *string `json:"type"`
}

WritableFrontPortTemplate writable front port template swagger:model WritableFrontPortTemplate

func (*WritableFrontPortTemplate) MarshalBinary 

func (m *WritableFrontPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableFrontPortTemplate) UnmarshalBinary 

func (m *WritableFrontPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableFrontPortTemplate) Validate 

func (m *WritableFrontPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable front port template

type WritableIPAddress 

type WritableIPAddress struct {

	// Address
	//
	// IPv4 or IPv6 address (with mask)
	// Required: true
	Address *string `json:"address"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// DNS Name
	//
	// Hostname or FQDN (not case-sensitive)
	// Max Length: 255
	// Pattern: ^[0-9A-Za-z._-]+$
	DNSName string `json:"dns_name,omitempty"`

	// Family
	// Read Only: true
	Family int64 `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Interface
	Interface *int64 `json:"interface,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// NAT (Inside)
	//
	// The IP for which this address is the "outside" IP
	NatInside *int64 `json:"nat_inside,omitempty"`

	// Nat outside
	// Required: true
	NatOutside *int64 `json:"nat_outside"`

	// Role
	//
	// The functional role of this IP
	// Enum: [loopback secondary anycast vip vrrp hsrp glbp carp]
	Role string `json:"role,omitempty"`

	// Status
	//
	// The operational status of this IP
	// Enum: [active reserved deprecated dhcp]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// VRF
	Vrf *int64 `json:"vrf,omitempty"`
}

WritableIPAddress writable IP address swagger:model WritableIPAddress

func (*WritableIPAddress) MarshalBinary 

func (m *WritableIPAddress) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableIPAddress) UnmarshalBinary 

func (m *WritableIPAddress) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableIPAddress) Validate 

func (m *WritableIPAddress) Validate(formats strfmt.Registry) error

Validate validates this writable IP address

type WritableInterfaceTemplate 

type WritableInterfaceTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Management only
	MgmtOnly bool `json:"mgmt_only,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Type
	// Required: true
	// Enum: [virtual lag 100base-tx 1000base-t 2.5gbase-t 5gbase-t 10gbase-t 10gbase-cx4 1000base-x-gbic 1000base-x-sfp 10gbase-x-sfpp 10gbase-x-xfp 10gbase-x-xenpak 10gbase-x-x2 25gbase-x-sfp28 40gbase-x-qsfpp 50gbase-x-sfp28 100gbase-x-cfp 100gbase-x-cfp2 200gbase-x-cfp2 100gbase-x-cfp4 100gbase-x-cpak 100gbase-x-qsfp28 200gbase-x-qsfp56 400gbase-x-qsfpdd 400gbase-x-osfp ieee802.11a ieee802.11g ieee802.11n ieee802.11ac ieee802.11ad ieee802.11ax gsm cdma lte sonet-oc3 sonet-oc12 sonet-oc48 sonet-oc192 sonet-oc768 sonet-oc1920 sonet-oc3840 1gfc-sfp 2gfc-sfp 4gfc-sfp 8gfc-sfpp 16gfc-sfpp 32gfc-sfp28 128gfc-sfp28 inifiband-sdr inifiband-ddr inifiband-qdr inifiband-fdr10 inifiband-fdr inifiband-edr inifiband-hdr inifiband-ndr inifiband-xdr t1 e1 t3 e3 cisco-stackwise cisco-stackwise-plus cisco-flexstack cisco-flexstack-plus juniper-vcp extreme-summitstack extreme-summitstack-128 extreme-summitstack-256 extreme-summitstack-512 other]
	Type *string `json:"type"`
}

WritableInterfaceTemplate writable interface template swagger:model WritableInterfaceTemplate

func (*WritableInterfaceTemplate) MarshalBinary 

func (m *WritableInterfaceTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableInterfaceTemplate) UnmarshalBinary 

func (m *WritableInterfaceTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableInterfaceTemplate) Validate 

func (m *WritableInterfaceTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable interface template

type WritableInventoryItem 

type WritableInventoryItem struct {

	// Asset tag
	//
	// A unique tag used to identify this item
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// Discovered
	Discovered bool `json:"discovered,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Manufacturer
	Manufacturer *int64 `json:"manufacturer,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Parent
	Parent *int64 `json:"parent,omitempty"`

	// Part ID
	// Max Length: 50
	PartID string `json:"part_id,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// tags
	Tags []string `json:"tags"`
}

WritableInventoryItem writable inventory item swagger:model WritableInventoryItem

func (*WritableInventoryItem) MarshalBinary 

func (m *WritableInventoryItem) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableInventoryItem) UnmarshalBinary 

func (m *WritableInventoryItem) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableInventoryItem) Validate 

func (m *WritableInventoryItem) Validate(formats strfmt.Registry) error

Validate validates this writable inventory item

type WritablePlatform 

type WritablePlatform struct {

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Manufacturer
	//
	// Optionally limit this platform to devices of a certain manufacturer
	Manufacturer *int64 `json:"manufacturer,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// NAPALM arguments
	//
	// Additional arguments to pass when initiating the NAPALM driver (JSON format)
	NapalmArgs *string `json:"napalm_args,omitempty"`

	// NAPALM driver
	//
	// The name of the NAPALM driver to use when interacting with devices
	// Max Length: 50
	NapalmDriver string `json:"napalm_driver,omitempty"`

	// Slug
	// Required: true
	// Max Length: 100
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`
}

WritablePlatform writable platform swagger:model WritablePlatform

func (*WritablePlatform) MarshalBinary 

func (m *WritablePlatform) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePlatform) UnmarshalBinary 

func (m *WritablePlatform) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePlatform) Validate 

func (m *WritablePlatform) Validate(formats strfmt.Registry) error

Validate validates this writable platform

type WritablePowerFeed 

type WritablePowerFeed struct {

	// Amperage
	// Maximum: 32767
	// Minimum: 1
	Amperage int64 `json:"amperage,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Max utilization
	//
	// Maximum permissible draw (percentage)
	// Maximum: 100
	// Minimum: 1
	MaxUtilization int64 `json:"max_utilization,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Phase
	// Enum: [single-phase three-phase]
	Phase string `json:"phase,omitempty"`

	// Power panel
	// Required: true
	PowerPanel *int64 `json:"power_panel"`

	// Rack
	Rack *int64 `json:"rack,omitempty"`

	// Status
	// Enum: [offline active planned failed]
	Status string `json:"status,omitempty"`

	// Supply
	// Enum: [ac dc]
	Supply string `json:"supply,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Enum: [primary redundant]
	Type string `json:"type,omitempty"`

	// Voltage
	// Maximum: 32767
	// Minimum: 1
	Voltage int64 `json:"voltage,omitempty"`
}

WritablePowerFeed writable power feed swagger:model WritablePowerFeed

func (*WritablePowerFeed) MarshalBinary 

func (m *WritablePowerFeed) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerFeed) UnmarshalBinary 

func (m *WritablePowerFeed) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerFeed) Validate 

func (m *WritablePowerFeed) Validate(formats strfmt.Registry) error

Validate validates this writable power feed

type WritablePowerOutlet 

type WritablePowerOutlet struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// Feed leg
	//
	// Phase (for three-phase feeds)
	// Enum: [A B C]
	FeedLeg string `json:"feed_leg,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Power port
	PowerPort *int64 `json:"power_port,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Enum: [iec-60320-c5 iec-60320-c7 iec-60320-c13 iec-60320-c15 iec-60320-c19 iec-60309-p-n-e-4h iec-60309-p-n-e-6h iec-60309-p-n-e-9h iec-60309-2p-e-4h iec-60309-2p-e-6h iec-60309-2p-e-9h iec-60309-3p-e-4h iec-60309-3p-e-6h iec-60309-3p-e-9h iec-60309-3p-n-e-4h iec-60309-3p-n-e-6h iec-60309-3p-n-e-9h nema-5-15r nema-5-20r nema-5-30r nema-5-50r nema-6-15r nema-6-20r nema-6-30r nema-6-50r nema-l5-15r nema-l5-20r nema-l5-30r nema-l5-50r nema-l6-20r nema-l6-30r nema-l6-50r CS6360C CS6364C CS8164C CS8264C CS8364C CS8464C ita-e ita-f ita-g ita-h ita-i ita-j ita-k ita-l ita-m ita-n ita-o]
	Type string `json:"type,omitempty"`
}

WritablePowerOutlet writable power outlet swagger:model WritablePowerOutlet

func (*WritablePowerOutlet) MarshalBinary 

func (m *WritablePowerOutlet) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerOutlet) UnmarshalBinary 

func (m *WritablePowerOutlet) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerOutlet) Validate 

func (m *WritablePowerOutlet) Validate(formats strfmt.Registry) error

Validate validates this writable power outlet

type WritablePowerOutletTemplate 

type WritablePowerOutletTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// Feed leg
	//
	// Phase (for three-phase feeds)
	// Enum: [A B C]
	FeedLeg string `json:"feed_leg,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Power port
	PowerPort *int64 `json:"power_port,omitempty"`

	// Type
	// Enum: [iec-60320-c5 iec-60320-c7 iec-60320-c13 iec-60320-c15 iec-60320-c19 iec-60309-p-n-e-4h iec-60309-p-n-e-6h iec-60309-p-n-e-9h iec-60309-2p-e-4h iec-60309-2p-e-6h iec-60309-2p-e-9h iec-60309-3p-e-4h iec-60309-3p-e-6h iec-60309-3p-e-9h iec-60309-3p-n-e-4h iec-60309-3p-n-e-6h iec-60309-3p-n-e-9h nema-5-15r nema-5-20r nema-5-30r nema-5-50r nema-6-15r nema-6-20r nema-6-30r nema-6-50r nema-l5-15r nema-l5-20r nema-l5-30r nema-l5-50r nema-l6-20r nema-l6-30r nema-l6-50r CS6360C CS6364C CS8164C CS8264C CS8364C CS8464C ita-e ita-f ita-g ita-h ita-i ita-j ita-k ita-l ita-m ita-n ita-o]
	Type string `json:"type,omitempty"`
}

WritablePowerOutletTemplate writable power outlet template swagger:model WritablePowerOutletTemplate

func (*WritablePowerOutletTemplate) MarshalBinary 

func (m *WritablePowerOutletTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerOutletTemplate) UnmarshalBinary 

func (m *WritablePowerOutletTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerOutletTemplate) Validate 

func (m *WritablePowerOutletTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable power outlet template

type WritablePowerPanel 

type WritablePowerPanel struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// Rack group
	RackGroup *int64 `json:"rack_group,omitempty"`

	// Site
	// Required: true
	Site *int64 `json:"site"`
}

WritablePowerPanel writable power panel swagger:model WritablePowerPanel

func (*WritablePowerPanel) MarshalBinary 

func (m *WritablePowerPanel) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerPanel) UnmarshalBinary 

func (m *WritablePowerPanel) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerPanel) Validate 

func (m *WritablePowerPanel) Validate(formats strfmt.Registry) error

Validate validates this writable power panel

type WritablePowerPort 

type WritablePowerPort struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Connected endpoint
	//
	//
	//         Return the appropriate serializer for the type of connected object.
	//
	// Read Only: true
	ConnectedEndpoint map[string]string `json:"connected_endpoint,omitempty"`

	// Connected endpoint type
	// Read Only: true
	ConnectedEndpointType string `json:"connected_endpoint_type,omitempty"`

	// Connection status
	// Enum: [false true]
	ConnectionStatus bool `json:"connection_status,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Enum: [iec-60320-c6 iec-60320-c8 iec-60320-c14 iec-60320-c16 iec-60320-c20 iec-60309-p-n-e-4h iec-60309-p-n-e-6h iec-60309-p-n-e-9h iec-60309-2p-e-4h iec-60309-2p-e-6h iec-60309-2p-e-9h iec-60309-3p-e-4h iec-60309-3p-e-6h iec-60309-3p-e-9h iec-60309-3p-n-e-4h iec-60309-3p-n-e-6h iec-60309-3p-n-e-9h nema-5-15p nema-5-20p nema-5-30p nema-5-50p nema-6-15p nema-6-20p nema-6-30p nema-6-50p nema-l5-15p nema-l5-20p nema-l5-30p nema-l5-50p nema-l6-20p nema-l6-30p nema-l6-50p cs6361c cs6365c cs8165c cs8265c cs8365c cs8465c ita-e ita-f ita-ef ita-g ita-h ita-i ita-j ita-k ita-l ita-m ita-n ita-o]
	Type string `json:"type,omitempty"`
}

WritablePowerPort writable power port swagger:model WritablePowerPort

func (*WritablePowerPort) MarshalBinary 

func (m *WritablePowerPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerPort) UnmarshalBinary 

func (m *WritablePowerPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerPort) Validate 

func (m *WritablePowerPort) Validate(formats strfmt.Registry) error

Validate validates this writable power port

type WritablePowerPortTemplate 

type WritablePowerPortTemplate struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Type
	// Enum: [iec-60320-c6 iec-60320-c8 iec-60320-c14 iec-60320-c16 iec-60320-c20 iec-60309-p-n-e-4h iec-60309-p-n-e-6h iec-60309-p-n-e-9h iec-60309-2p-e-4h iec-60309-2p-e-6h iec-60309-2p-e-9h iec-60309-3p-e-4h iec-60309-3p-e-6h iec-60309-3p-e-9h iec-60309-3p-n-e-4h iec-60309-3p-n-e-6h iec-60309-3p-n-e-9h nema-5-15p nema-5-20p nema-5-30p nema-5-50p nema-6-15p nema-6-20p nema-6-30p nema-6-50p nema-l5-15p nema-l5-20p nema-l5-30p nema-l5-50p nema-l6-20p nema-l6-30p nema-l6-50p cs6361c cs6365c cs8165c cs8265c cs8365c cs8465c ita-e ita-f ita-ef ita-g ita-h ita-i ita-j ita-k ita-l ita-m ita-n ita-o]
	Type string `json:"type,omitempty"`
}

WritablePowerPortTemplate writable power port template swagger:model WritablePowerPortTemplate

func (*WritablePowerPortTemplate) MarshalBinary 

func (m *WritablePowerPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePowerPortTemplate) UnmarshalBinary 

func (m *WritablePowerPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePowerPortTemplate) Validate 

func (m *WritablePowerPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable power port template

type WritablePrefix 

type WritablePrefix struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Family
	// Read Only: true
	Family int64 `json:"family,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Is a pool
	//
	// All IP addresses within this prefix are considered usable
	IsPool bool `json:"is_pool,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Prefix
	//
	// IPv4 or IPv6 network with mask
	// Required: true
	Prefix *string `json:"prefix"`

	// Role
	//
	// The primary function of this prefix
	Role *int64 `json:"role,omitempty"`

	// Site
	Site *int64 `json:"site,omitempty"`

	// Status
	//
	// Operational status of this prefix
	// Enum: [container active reserved deprecated]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// VLAN
	Vlan *int64 `json:"vlan,omitempty"`

	// VRF
	Vrf *int64 `json:"vrf,omitempty"`
}

WritablePrefix writable prefix swagger:model WritablePrefix

func (*WritablePrefix) MarshalBinary 

func (m *WritablePrefix) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritablePrefix) UnmarshalBinary 

func (m *WritablePrefix) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritablePrefix) Validate 

func (m *WritablePrefix) Validate(formats strfmt.Registry) error

Validate validates this writable prefix

type WritableRack 

type WritableRack struct {

	// Asset tag
	//
	// A unique tag used to identify this rack
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Descending units
	//
	// Units are numbered top-to-bottom
	DescUnits bool `json:"desc_units,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Facility ID
	// Max Length: 50
	FacilityID *string `json:"facility_id,omitempty"`

	// Group
	Group *int64 `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Outer depth
	// Maximum: 32767
	// Minimum: 0
	OuterDepth *int64 `json:"outer_depth,omitempty"`

	// Outer unit
	// Enum: [mm in]
	OuterUnit string `json:"outer_unit,omitempty"`

	// Outer width
	// Maximum: 32767
	// Minimum: 0
	OuterWidth *int64 `json:"outer_width,omitempty"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// Role
	Role *int64 `json:"role,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

	// Site
	// Required: true
	Site *int64 `json:"site"`

	// Status
	// Enum: [reserved available planned active deprecated]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// Type
	// Enum: [2-post-frame 4-post-frame 4-post-cabinet wall-frame wall-cabinet]
	Type string `json:"type,omitempty"`

	// Height (U)
	// Maximum: 100
	// Minimum: 1
	UHeight int64 `json:"u_height,omitempty"`

	// Width
	//
	// Rail-to-rail width
	// Enum: [19 23]
	Width int64 `json:"width,omitempty"`
}

WritableRack writable rack swagger:model WritableRack

func (*WritableRack) MarshalBinary 

func (m *WritableRack) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRack) UnmarshalBinary 

func (m *WritableRack) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRack) Validate 

func (m *WritableRack) Validate(formats strfmt.Registry) error

Validate validates this writable rack

type WritableRackGroup 

type WritableRackGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Site
	// Required: true
	Site *int64 `json:"site"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

WritableRackGroup writable rack group swagger:model WritableRackGroup

func (*WritableRackGroup) MarshalBinary 

func (m *WritableRackGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRackGroup) UnmarshalBinary 

func (m *WritableRackGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRackGroup) Validate 

func (m *WritableRackGroup) Validate(formats strfmt.Registry) error

Validate validates this writable rack group

type WritableRackReservation 

type WritableRackReservation struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Description
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Description *string `json:"description"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Rack
	// Required: true
	Rack *int64 `json:"rack"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// units
	// Required: true
	Units []*int64 `json:"units"`

	// User
	// Required: true
	User *int64 `json:"user"`
}

WritableRackReservation writable rack reservation swagger:model WritableRackReservation

func (*WritableRackReservation) MarshalBinary 

func (m *WritableRackReservation) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRackReservation) UnmarshalBinary 

func (m *WritableRackReservation) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRackReservation) Validate 

func (m *WritableRackReservation) Validate(formats strfmt.Registry) error

Validate validates this writable rack reservation

type WritableRearPort 

type WritableRearPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Required: true
	// Enum: [8p8c 110-punch bnc fc lc lc-apc lsh lsh-apc mpo mtrj sc sc-apc st]
	Type *string `json:"type"`
}

WritableRearPort writable rear port swagger:model WritableRearPort

func (*WritableRearPort) MarshalBinary 

func (m *WritableRearPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRearPort) UnmarshalBinary 

func (m *WritableRearPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRearPort) Validate 

func (m *WritableRearPort) Validate(formats strfmt.Registry) error

Validate validates this writable rear port

type WritableRearPortTemplate 

type WritableRearPortTemplate struct {

	// Device type
	// Required: true
	DeviceType *int64 `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// Type
	// Required: true
	// Enum: [8p8c 110-punch bnc fc lc lc-apc lsh lsh-apc mpo mtrj sc sc-apc st]
	Type *string `json:"type"`
}

WritableRearPortTemplate writable rear port template swagger:model WritableRearPortTemplate

func (*WritableRearPortTemplate) MarshalBinary 

func (m *WritableRearPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRearPortTemplate) UnmarshalBinary 

func (m *WritableRearPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRearPortTemplate) Validate 

func (m *WritableRearPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this writable rear port template

type WritableRegion 

type WritableRegion struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Parent
	Parent *int64 `json:"parent,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

WritableRegion writable region swagger:model WritableRegion

func (*WritableRegion) MarshalBinary 

func (m *WritableRegion) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableRegion) UnmarshalBinary 

func (m *WritableRegion) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableRegion) Validate 

func (m *WritableRegion) Validate(formats strfmt.Registry) error

Validate validates this writable region

type WritableSecret 

type WritableSecret struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Device
	// Required: true
	Device *int64 `json:"device"`

	// Hash
	// Read Only: true
	// Min Length: 1
	Hash string `json:"hash,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Max Length: 100
	Name string `json:"name,omitempty"`

	// Plaintext
	// Required: true
	// Min Length: 1
	Plaintext *string `json:"plaintext"`

	// Role
	// Required: true
	Role *int64 `json:"role"`

	// tags
	Tags []string `json:"tags"`
}

WritableSecret writable secret swagger:model WritableSecret

func (*WritableSecret) MarshalBinary 

func (m *WritableSecret) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableSecret) UnmarshalBinary 

func (m *WritableSecret) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableSecret) Validate 

func (m *WritableSecret) Validate(formats strfmt.Registry) error

Validate validates this writable secret

type WritableService 

type WritableService struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device
	Device *int64 `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// ipaddresses
	// Unique: true
	Ipaddresses []int64 `json:"ipaddresses"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Port number
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	Port *int64 `json:"port"`

	// Protocol
	// Required: true
	// Enum: [tcp udp]
	Protocol *string `json:"protocol"`

	// tags
	Tags []string `json:"tags"`

	// Virtual machine
	VirtualMachine *int64 `json:"virtual_machine,omitempty"`
}

WritableService writable service swagger:model WritableService

func (*WritableService) MarshalBinary 

func (m *WritableService) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableService) UnmarshalBinary 

func (m *WritableService) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableService) Validate 

func (m *WritableService) Validate(formats strfmt.Registry) error

Validate validates this writable service

type WritableSite 

type WritableSite struct {

	// ASN
	// Maximum: 4.294967295e+09
	// Minimum: 1
	Asn *int64 `json:"asn,omitempty"`

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Contact E-mail
	// Max Length: 254
	// Format: email
	ContactEmail strfmt.Email `json:"contact_email,omitempty"`

	// Contact name
	// Max Length: 50
	ContactName string `json:"contact_name,omitempty"`

	// Contact phone
	// Max Length: 20
	ContactPhone string `json:"contact_phone,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Facility
	// Max Length: 50
	Facility string `json:"facility,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Latitude
	Latitude *string `json:"latitude,omitempty"`

	// Longitude
	Longitude *string `json:"longitude,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Physical address
	// Max Length: 200
	PhysicalAddress string `json:"physical_address,omitempty"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Region
	Region *int64 `json:"region,omitempty"`

	// Shipping address
	// Max Length: 200
	ShippingAddress string `json:"shipping_address,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Status
	// Enum: [active planned retired]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// Time zone
	TimeZone string `json:"time_zone,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

WritableSite writable site swagger:model WritableSite

func (*WritableSite) MarshalBinary 

func (m *WritableSite) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableSite) UnmarshalBinary 

func (m *WritableSite) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableSite) Validate 

func (m *WritableSite) Validate(formats strfmt.Registry) error

Validate validates this writable site

type WritableTenant 

type WritableTenant struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	//
	// Long-form name (optional)
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Group
	Group *int64 `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Ipaddress count
	// Read Only: true
	IpaddressCount int64 `json:"ipaddress_count,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// tags
	Tags []string `json:"tags"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`

	// Vrf count
	// Read Only: true
	VrfCount int64 `json:"vrf_count,omitempty"`
}

WritableTenant writable tenant swagger:model WritableTenant

func (*WritableTenant) MarshalBinary 

func (m *WritableTenant) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableTenant) UnmarshalBinary 

func (m *WritableTenant) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableTenant) Validate 

func (m *WritableTenant) Validate(formats strfmt.Registry) error

Validate validates this writable tenant

type WritableVLAN 

type WritableVLAN struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Group
	Group *int64 `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Role
	Role *int64 `json:"role,omitempty"`

	// Site
	Site *int64 `json:"site,omitempty"`

	// Status
	// Enum: [active reserved deprecated]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// ID
	// Required: true
	// Maximum: 4094
	// Minimum: 1
	Vid *int64 `json:"vid"`
}

WritableVLAN writable v l a n swagger:model WritableVLAN

func (*WritableVLAN) MarshalBinary 

func (m *WritableVLAN) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVLAN) UnmarshalBinary 

func (m *WritableVLAN) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVLAN) Validate 

func (m *WritableVLAN) Validate(formats strfmt.Registry) error

Validate validates this writable v l a n

type WritableVLANGroup 

type WritableVLANGroup struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Site
	Site *int64 `json:"site,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

WritableVLANGroup writable v l a n group swagger:model WritableVLANGroup

func (*WritableVLANGroup) MarshalBinary 

func (m *WritableVLANGroup) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVLANGroup) UnmarshalBinary 

func (m *WritableVLANGroup) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVLANGroup) Validate 

func (m *WritableVLANGroup) Validate(formats strfmt.Registry) error

Validate validates this writable v l a n group

type WritableVRF 

type WritableVRF struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Enforce unique space
	//
	// Prevent duplicate prefixes/IP addresses within this VRF
	EnforceUnique bool `json:"enforce_unique,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Ipaddress count
	// Read Only: true
	IpaddressCount int64 `json:"ipaddress_count,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Route distinguisher
	// Max Length: 21
	Rd *string `json:"rd,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`
}

WritableVRF writable v r f swagger:model WritableVRF

func (*WritableVRF) MarshalBinary 

func (m *WritableVRF) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVRF) UnmarshalBinary 

func (m *WritableVRF) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVRF) Validate 

func (m *WritableVRF) Validate(formats strfmt.Registry) error

Validate validates this writable v r f

type WritableVirtualChassis 

type WritableVirtualChassis struct {

	// Domain
	// Max Length: 30
	Domain string `json:"domain,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Master
	// Required: true
	Master *int64 `json:"master"`

	// Member count
	// Read Only: true
	MemberCount int64 `json:"member_count,omitempty"`

	// tags
	Tags []string `json:"tags"`
}

WritableVirtualChassis writable virtual chassis swagger:model WritableVirtualChassis

func (*WritableVirtualChassis) MarshalBinary 

func (m *WritableVirtualChassis) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVirtualChassis) UnmarshalBinary 

func (m *WritableVirtualChassis) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVirtualChassis) Validate 

func (m *WritableVirtualChassis) Validate(formats strfmt.Registry) error

Validate validates this writable virtual chassis

type WritableVirtualMachineInterface 

type WritableVirtualMachineInterface struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Enabled
	Enabled bool `json:"enabled,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// MAC Address
	MacAddress *string `json:"mac_address,omitempty"`

	// Mode
	// Enum: [access tagged tagged-all]
	Mode string `json:"mode,omitempty"`

	// MTU
	// Maximum: 65536
	// Minimum: 1
	Mtu *int64 `json:"mtu,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// tagged vlans
	// Unique: true
	TaggedVlans []int64 `json:"tagged_vlans"`

	// tags
	Tags []string `json:"tags"`

	// Type
	// Required: true
	// Enum: [virtual lag 100base-tx 1000base-t 2.5gbase-t 5gbase-t 10gbase-t 10gbase-cx4 1000base-x-gbic 1000base-x-sfp 10gbase-x-sfpp 10gbase-x-xfp 10gbase-x-xenpak 10gbase-x-x2 25gbase-x-sfp28 40gbase-x-qsfpp 50gbase-x-sfp28 100gbase-x-cfp 100gbase-x-cfp2 200gbase-x-cfp2 100gbase-x-cfp4 100gbase-x-cpak 100gbase-x-qsfp28 200gbase-x-qsfp56 400gbase-x-qsfpdd 400gbase-x-osfp ieee802.11a ieee802.11g ieee802.11n ieee802.11ac ieee802.11ad ieee802.11ax gsm cdma lte sonet-oc3 sonet-oc12 sonet-oc48 sonet-oc192 sonet-oc768 sonet-oc1920 sonet-oc3840 1gfc-sfp 2gfc-sfp 4gfc-sfp 8gfc-sfpp 16gfc-sfpp 32gfc-sfp28 128gfc-sfp28 inifiband-sdr inifiband-ddr inifiband-qdr inifiband-fdr10 inifiband-fdr inifiband-edr inifiband-hdr inifiband-ndr inifiband-xdr t1 e1 t3 e3 cisco-stackwise cisco-stackwise-plus cisco-flexstack cisco-flexstack-plus juniper-vcp extreme-summitstack extreme-summitstack-128 extreme-summitstack-256 extreme-summitstack-512 other]
	Type *string `json:"type"`

	// Untagged VLAN
	UntaggedVlan *int64 `json:"untagged_vlan,omitempty"`

	// Virtual machine
	VirtualMachine *int64 `json:"virtual_machine,omitempty"`
}

WritableVirtualMachineInterface writable virtual machine interface swagger:model WritableVirtualMachineInterface

func (*WritableVirtualMachineInterface) MarshalBinary 

func (m *WritableVirtualMachineInterface) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVirtualMachineInterface) UnmarshalBinary 

func (m *WritableVirtualMachineInterface) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVirtualMachineInterface) Validate 

func (m *WritableVirtualMachineInterface) Validate(formats strfmt.Registry) error

Validate validates this writable virtual machine interface

type WritableVirtualMachineWithConfigContext 

type WritableVirtualMachineWithConfigContext struct {

	// Cluster
	// Required: true
	Cluster *int64 `json:"cluster"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Config context
	// Read Only: true
	ConfigContext map[string]string `json:"config_context,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Disk (GB)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	Disk *int64 `json:"disk,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Memory (MB)
	// Maximum: 2.147483647e+09
	// Minimum: 0
	Memory *int64 `json:"memory,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Platform
	Platform *int64 `json:"platform,omitempty"`

	// Primary ip
	// Read Only: true
	PrimaryIP string `json:"primary_ip,omitempty"`

	// Primary IPv4
	PrimaryIp4 *int64 `json:"primary_ip4,omitempty"`

	// Primary IPv6
	PrimaryIp6 *int64 `json:"primary_ip6,omitempty"`

	// Role
	Role *int64 `json:"role,omitempty"`

	// Site
	// Read Only: true
	Site string `json:"site,omitempty"`

	// Status
	// Enum: [offline active planned staged failed decommissioning]
	Status string `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// Tenant
	Tenant *int64 `json:"tenant,omitempty"`

	// VCPUs
	// Maximum: 32767
	// Minimum: 0
	Vcpus *int64 `json:"vcpus,omitempty"`
}

WritableVirtualMachineWithConfigContext writable virtual machine with config context swagger:model WritableVirtualMachineWithConfigContext

func (*WritableVirtualMachineWithConfigContext) MarshalBinary 

func (m *WritableVirtualMachineWithConfigContext) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*WritableVirtualMachineWithConfigContext) UnmarshalBinary 

func (m *WritableVirtualMachineWithConfigContext) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*WritableVirtualMachineWithConfigContext) Validate 

func (m *WritableVirtualMachineWithConfigContext) Validate(formats strfmt.Registry) error

Validate validates this writable virtual machine with config context

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.