models

package
Version: 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

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

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

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

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

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

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)