Back to godoc.org

Package models

v0.0.0-...-fd776ef
Latest Go to latest

The highest tagged major version is .

Published: Feb 3, 2020 | License: Apache-2.0 | Module: code.fbi.h-da.de/its/go-netbox

Index

Constants

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"
)
const (

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

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

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

	// GraphTemplateLanguageJinja2 captures enum value "jinja2"
	GraphTemplateLanguageJinja2 string = "jinja2"
)
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"
)
const (

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

	// WritableCableStatusPlanned captures enum value "planned"
	WritableCableStatusPlanned string = "planned"
)
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"
)
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"
)
const (

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

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

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

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

	// 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"
)
const (

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

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

	// 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"
)
const (

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

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

	// 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"
)
const (

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

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

	// 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"
)
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"
)
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"
)
const (

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

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

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

	// WritableDeviceWithConfigContextFaceRear captures enum value "rear"
	WritableDeviceWithConfigContextFaceRear string = "rear"
)
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"
)
const (

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

	// WritableExportTemplateTemplateLanguageJinja2 captures enum value "jinja2"
	WritableExportTemplateTemplateLanguageJinja2 string = "jinja2"
)
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"
)
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"
)
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"
)
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"
)
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"
)
const (

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

	// WritablePowerFeedPhaseThreePhase captures enum value "three-phase"
	WritablePowerFeedPhaseThreePhase string = "three-phase"
)
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"
)
const (

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

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

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

	// WritablePowerFeedTypeRedundant captures enum value "redundant"
	WritablePowerFeedTypeRedundant string = "redundant"
)
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"
)
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"
)
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"
)
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"
)
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"
)
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"
)
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"
)
const (

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

	// WritableRackOuterUnitIn captures enum value "in"
	WritableRackOuterUnitIn string = "in"
)
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"
)
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"
)
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"
)
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"
)
const (

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

	// WritableServiceProtocolUDP captures enum value "udp"
	WritableServiceProtocolUDP string = "udp"
)
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"
)
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"
)
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"
)
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"
)
const (

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

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

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

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 Cable

type Cable struct {

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

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

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

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

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

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

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

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

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

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

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

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

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

Cable cable swagger:model Cable

func (*Cable) MarshalBinary

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

MarshalBinary interface implementation

func (*Cable) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Cable) Validate

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

Validate validates this cable

type CableLengthUnit

type CableLengthUnit struct {

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

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

CableLengthUnit Length unit swagger:model CableLengthUnit

func (*CableLengthUnit) MarshalBinary

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

MarshalBinary interface implementation

func (*CableLengthUnit) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CableLengthUnit) Validate

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

Validate validates this cable length unit

type CableStatus

type CableStatus struct {

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

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

CableStatus Status swagger:model CableStatus

func (*CableStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*CableStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CableStatus) Validate

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

Validate validates this cable status

type Circuit

type Circuit struct {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Circuit circuit swagger:model Circuit

func (*Circuit) MarshalBinary

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

MarshalBinary interface implementation

func (*Circuit) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Circuit) Validate

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

Validate validates this circuit

type CircuitCircuitTermination

type CircuitCircuitTermination struct {

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

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

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

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

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

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

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

CircuitCircuitTermination Termination a swagger:model CircuitCircuitTermination

func (*CircuitCircuitTermination) MarshalBinary

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

MarshalBinary interface implementation

func (*CircuitCircuitTermination) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CircuitCircuitTermination) Validate

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

Validate validates this circuit circuit termination

type CircuitStatus

type CircuitStatus struct {

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

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

CircuitStatus Status swagger:model CircuitStatus

func (*CircuitStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*CircuitStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CircuitStatus) Validate

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

Validate validates this circuit status

type CircuitTermination

type CircuitTermination struct {

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

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

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

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

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

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

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

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

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

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

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

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

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

CircuitTermination circuit termination swagger:model CircuitTermination

func (*CircuitTermination) MarshalBinary

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

MarshalBinary interface implementation

func (*CircuitTermination) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CircuitTermination) Validate

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

Validate validates this circuit termination

type CircuitTerminationConnectionStatus

type CircuitTerminationConnectionStatus struct {

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

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

CircuitTerminationConnectionStatus Connection status swagger:model CircuitTerminationConnectionStatus

func (*CircuitTerminationConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*CircuitTerminationConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CircuitTerminationConnectionStatus) Validate

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

Validate validates this circuit termination connection status

type CircuitType

type CircuitType struct {

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

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

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

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

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

CircuitType circuit type swagger:model CircuitType

func (*CircuitType) MarshalBinary

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

MarshalBinary interface implementation

func (*CircuitType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*CircuitType) Validate

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

Validate validates this circuit type

type Cluster

type Cluster struct {

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

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

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

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

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

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

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

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

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

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

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

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

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

Cluster cluster swagger:model Cluster

func (*Cluster) MarshalBinary

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

MarshalBinary interface implementation

func (*Cluster) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Cluster) Validate

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

Validate validates this cluster

type ClusterGroup

type ClusterGroup struct {

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

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

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

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

ClusterGroup cluster group swagger:model ClusterGroup

func (*ClusterGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*ClusterGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ClusterGroup) Validate

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

Validate validates this cluster group

type ClusterType

type ClusterType struct {

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

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

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

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

ClusterType cluster type swagger:model ClusterType

func (*ClusterType) MarshalBinary

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

MarshalBinary interface implementation

func (*ClusterType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ClusterType) Validate

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

Validate validates this cluster type

type ConfigContext

type ConfigContext struct {

	// Data
	// Required: true
	Data *string `json:"data"`

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

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

	// Is active
	IsActive bool `json:"is_active,omitempty"`

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

	// platforms
	// Unique: true
	Platforms []*NestedPlatform `json:"platforms"`

	// regions
	// Unique: true
	Regions []*NestedRegion `json:"regions"`

	// roles
	// Unique: true
	Roles []*NestedDeviceRole `json:"roles"`

	// sites
	// Unique: true
	Sites []*NestedSite `json:"sites"`

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

	// tenant groups
	// Unique: true
	TenantGroups []*NestedTenantGroup `json:"tenant_groups"`

	// tenants
	// Unique: true
	Tenants []*NestedTenant `json:"tenants"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

ConfigContext config context swagger:model ConfigContext

func (*ConfigContext) MarshalBinary

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

MarshalBinary interface implementation

func (*ConfigContext) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConfigContext) Validate

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

Validate validates this config context

type ConsolePort

type ConsolePort struct {

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

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

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

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

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

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

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

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

	// type
	Type *ConsolePortType `json:"type,omitempty"`
}

ConsolePort console port swagger:model ConsolePort

func (*ConsolePort) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsolePort) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsolePort) Validate

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

Validate validates this console port

type ConsolePortConnectionStatus

type ConsolePortConnectionStatus struct {

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

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

ConsolePortConnectionStatus Connection status swagger:model ConsolePortConnectionStatus

func (*ConsolePortConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsolePortConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsolePortConnectionStatus) Validate

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

Validate validates this console port connection status

type ConsolePortTemplate

type ConsolePortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

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

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

	// type
	Type *ConsolePortTemplateType `json:"type,omitempty"`
}

ConsolePortTemplate console port template swagger:model ConsolePortTemplate

func (*ConsolePortTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsolePortTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsolePortTemplate) Validate

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

Validate validates this console port template

type ConsolePortTemplateType

type ConsolePortTemplateType struct {

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

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

ConsolePortTemplateType Type swagger:model ConsolePortTemplateType

func (*ConsolePortTemplateType) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsolePortTemplateType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsolePortTemplateType) Validate

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

Validate validates this console port template type

type ConsolePortType

type ConsolePortType struct {

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

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

ConsolePortType Type swagger:model ConsolePortType

func (*ConsolePortType) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsolePortType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsolePortType) Validate

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

Validate validates this console port type

type ConsoleServerPort

type ConsoleServerPort struct {

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

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

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

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

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

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

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

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

	// type
	Type *ConsoleServerPortType `json:"type,omitempty"`
}

ConsoleServerPort console server port swagger:model ConsoleServerPort

func (*ConsoleServerPort) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsoleServerPort) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsoleServerPort) Validate

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

Validate validates this console server port

type ConsoleServerPortConnectionStatus

type ConsoleServerPortConnectionStatus struct {

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

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

ConsoleServerPortConnectionStatus Connection status swagger:model ConsoleServerPortConnectionStatus

func (*ConsoleServerPortConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsoleServerPortConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsoleServerPortConnectionStatus) Validate

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

Validate validates this console server port connection status

type ConsoleServerPortTemplate

type ConsoleServerPortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

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

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

	// type
	Type *ConsoleServerPortTemplateType `json:"type,omitempty"`
}

ConsoleServerPortTemplate console server port template swagger:model ConsoleServerPortTemplate

func (*ConsoleServerPortTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsoleServerPortTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsoleServerPortTemplate) Validate

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

Validate validates this console server port template

type ConsoleServerPortTemplateType

type ConsoleServerPortTemplateType struct {

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

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

ConsoleServerPortTemplateType Type swagger:model ConsoleServerPortTemplateType

func (*ConsoleServerPortTemplateType) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsoleServerPortTemplateType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsoleServerPortTemplateType) Validate

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

Validate validates this console server port template type

type ConsoleServerPortType

type ConsoleServerPortType struct {

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

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

ConsoleServerPortType Type swagger:model ConsoleServerPortType

func (*ConsoleServerPortType) MarshalBinary

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

MarshalBinary interface implementation

func (*ConsoleServerPortType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ConsoleServerPortType) Validate

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

Validate validates this console server port type

type Device

type Device struct {

	// Asset tag
	//
	// A unique tag used to identify this device
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

	// cluster
	Cluster *NestedCluster `json:"cluster,omitempty"`

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

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

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

	// device role
	// Required: true
	DeviceRole *NestedDeviceRole `json:"device_role"`

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// face
	Face *DeviceFace `json:"face,omitempty"`

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

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

	// Local context data
	LocalContextData *string `json:"local_context_data,omitempty"`

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

	// parent device
	ParentDevice *NestedDevice `json:"parent_device,omitempty"`

	// platform
	Platform *NestedPlatform `json:"platform,omitempty"`

	// Position (U)
	//
	// The lowest-numbered unit occupied by the device
	// Maximum: 32767
	// Minimum: 1
	Position *int64 `json:"position,omitempty"`

	// primary ip
	PrimaryIP *NestedIPAddress `json:"primary_ip,omitempty"`

	// primary ip4
	PrimaryIp4 *NestedIPAddress `json:"primary_ip4,omitempty"`

	// primary ip6
	PrimaryIp6 *NestedIPAddress `json:"primary_ip6,omitempty"`

	// rack
	Rack *NestedRack `json:"rack,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

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

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

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

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

	// Vc position
	// Maximum: 255
	// Minimum: 0
	VcPosition *int64 `json:"vc_position,omitempty"`

	// Vc priority
	// Maximum: 255
	// Minimum: 0
	VcPriority *int64 `json:"vc_priority,omitempty"`

	// virtual chassis
	VirtualChassis *NestedVirtualChassis `json:"virtual_chassis,omitempty"`
}

Device device swagger:model Device

func (*Device) MarshalBinary

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

MarshalBinary interface implementation

func (*Device) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Device) Validate

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

Validate validates this device

type DeviceBay

type DeviceBay struct {

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

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

	// installed device
	InstalledDevice *NestedDevice `json:"installed_device,omitempty"`

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

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

DeviceBay device bay swagger:model DeviceBay

func (*DeviceBay) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceBay) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceBay) Validate

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

Validate validates this device bay

type DeviceBayTemplate

type DeviceBayTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

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

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

DeviceBayTemplate device bay template swagger:model DeviceBayTemplate

func (*DeviceBayTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceBayTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceBayTemplate) Validate

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

Validate validates this device bay template

type DeviceFace

type DeviceFace struct {

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

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

DeviceFace Face swagger:model DeviceFace

func (*DeviceFace) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceFace) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceFace) Validate

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

Validate validates this device face

type DeviceInterface

type DeviceInterface struct {

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

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

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

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

	// Count ipaddresses
	// Read Only: true
	CountIpaddresses string `json:"count_ipaddresses,omitempty"`

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Enabled
	Enabled bool `json:"enabled,omitempty"`

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

	// lag
	Lag *NestedInterface `json:"lag,omitempty"`

	// MAC Address
	MacAddress *string `json:"mac_address,omitempty"`

	// OOB Management
	//
	// This interface is used only for out-of-band management
	MgmtOnly bool `json:"mgmt_only,omitempty"`

	// mode
	Mode *DeviceInterfaceMode `json:"mode,omitempty"`

	// MTU
	// Maximum: 65536
	// Minimum: 1
	Mtu *int64 `json:"mtu,omitempty"`

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

	// tagged vlans
	// Unique: true
	TaggedVlans []*NestedVLAN `json:"tagged_vlans"`

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

	// type
	Type *DeviceInterfaceType `json:"type,omitempty"`

	// untagged vlan
	UntaggedVlan *NestedVLAN `json:"untagged_vlan,omitempty"`
}

DeviceInterface device interface swagger:model DeviceInterface

func (*DeviceInterface) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceInterface) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceInterface) Validate

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

Validate validates this device interface

type DeviceInterfaceConnectionStatus

type DeviceInterfaceConnectionStatus struct {

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

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

DeviceInterfaceConnectionStatus Connection status swagger:model DeviceInterfaceConnectionStatus

func (*DeviceInterfaceConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceInterfaceConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceInterfaceConnectionStatus) Validate

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

Validate validates this device interface connection status

type DeviceInterfaceMode

type DeviceInterfaceMode struct {

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

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

DeviceInterfaceMode Mode swagger:model DeviceInterfaceMode

func (*DeviceInterfaceMode) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceInterfaceMode) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceInterfaceMode) Validate

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

Validate validates this device interface mode

type DeviceInterfaceType

type DeviceInterfaceType struct {

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

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

DeviceInterfaceType Type swagger:model DeviceInterfaceType

func (*DeviceInterfaceType) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceInterfaceType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceInterfaceType) Validate

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

Validate validates this device interface type

type DeviceNAPALM

type DeviceNAPALM struct {

	// Method
	// Required: true
	Method map[string]string `json:"method"`
}

DeviceNAPALM device n a p a l m swagger:model DeviceNAPALM

func (*DeviceNAPALM) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceNAPALM) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceNAPALM) Validate

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

Validate validates this device n a p a l m

type DeviceRole

type DeviceRole struct {

	// Color
	// Required: true
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color *string `json:"color"`

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

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

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

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

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

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

	// VM Role
	//
	// Virtual machines may be assigned to this role
	VMRole bool `json:"vm_role,omitempty"`
}

DeviceRole device role swagger:model DeviceRole

func (*DeviceRole) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceRole) Validate

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

Validate validates this device role

type DeviceStatus

type DeviceStatus struct {

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

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

DeviceStatus Status swagger:model DeviceStatus

func (*DeviceStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*DeviceStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*DeviceStatus) Validate

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

Validate validates this device status

type DeviceType

type DeviceType struct {

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

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

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

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

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// 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"`

	// 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 *int64 `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 *string `json:"value"`
}

IPAddressFamily Family swagger:model IPAddressFamily

func (*IPAddressFamily) MarshalBinary

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

MarshalBinary interface implementation

func (*IPAddressFamily) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*IPAddressFamily) Validate

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

Validate validates this IP address family

type IPAddressInterface

type IPAddressInterface struct {

	// device
	Device *NestedDevice `json:"device,omitempty"`

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

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

	// Url
	// Read Only: true
	URL string `json:"url,omitempty"`

	// virtual machine
	VirtualMachine *NestedVirtualMachine `json:"virtual_machine,omitempty"`
}

IPAddressInterface Interface swagger:model IPAddressInterface

func (*IPAddressInterface) MarshalBinary

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

MarshalBinary interface implementation

func (*IPAddressInterface) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*IPAddressInterface) Validate

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

Validate validates this IP address interface

type IPAddressRole

type IPAddressRole struct {

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

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

IPAddressRole Role swagger:model IPAddressRole

func (*IPAddressRole) MarshalBinary

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

MarshalBinary interface implementation

func (*IPAddressRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*IPAddressRole) Validate

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

Validate validates this IP address role

type IPAddressStatus

type IPAddressStatus struct {

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

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

IPAddressStatus Status swagger:model IPAddressStatus

func (*IPAddressStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*IPAddressStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*IPAddressStatus) Validate

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

Validate validates this IP address status

type ImageAttachment

type ImageAttachment struct {

	// Content type
	// Required: true
	ContentType *string `json:"content_type"`

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

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

	// Image
	// Read Only: true
	// Format: uri
	Image strfmt.URI `json:"image,omitempty"`

	// Image height
	// Required: true
	// Maximum: 32767
	// Minimum: 0
	ImageHeight *int64 `json:"image_height"`

	// Image width
	// Required: true
	// Maximum: 32767
	// Minimum: 0
	ImageWidth *int64 `json:"image_width"`

	// Name
	// Max Length: 50
	Name string `json:"name,omitempty"`

	// Object id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	ObjectID *int64 `json:"object_id"`

	// Parent
	// Read Only: true
	Parent map[string]string `json:"parent,omitempty"`
}

ImageAttachment image attachment swagger:model ImageAttachment

func (*ImageAttachment) MarshalBinary

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

MarshalBinary interface implementation

func (*ImageAttachment) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ImageAttachment) Validate

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

Validate validates this image attachment

type InterfaceConnection

type InterfaceConnection struct {

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

	// interface a
	Interfacea *NestedInterface `json:"interface_a,omitempty"`

	// interface b
	// Required: true
	Interfaceb *NestedInterface `json:"interface_b"`
}

InterfaceConnection interface connection swagger:model InterfaceConnection

func (*InterfaceConnection) MarshalBinary

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

MarshalBinary interface implementation

func (*InterfaceConnection) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*InterfaceConnection) Validate

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

Validate validates this interface connection

type InterfaceConnectionConnectionStatus

type InterfaceConnectionConnectionStatus struct {

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

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

InterfaceConnectionConnectionStatus Connection status swagger:model InterfaceConnectionConnectionStatus

func (*InterfaceConnectionConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*InterfaceConnectionConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*InterfaceConnectionConnectionStatus) Validate

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

Validate validates this interface connection connection status

type InterfaceTemplate

type InterfaceTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

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

	// Management only
	MgmtOnly bool `json:"mgmt_only,omitempty"`

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

	// type
	Type *InterfaceTemplateType `json:"type,omitempty"`
}

InterfaceTemplate interface template swagger:model InterfaceTemplate

func (*InterfaceTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*InterfaceTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*InterfaceTemplate) Validate

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

Validate validates this interface template

type InterfaceTemplateType

type InterfaceTemplateType struct {

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

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

InterfaceTemplateType Type swagger:model InterfaceTemplateType

func (*InterfaceTemplateType) MarshalBinary

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

MarshalBinary interface implementation

func (*InterfaceTemplateType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*InterfaceTemplateType) Validate

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

Validate validates this interface template type

type InventoryItem

type InventoryItem struct {

	// Asset tag
	//
	// A unique tag used to identify this item
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Discovered
	Discovered bool `json:"discovered,omitempty"`

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

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

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

	// Parent
	Parent *int64 `json:"parent,omitempty"`

	// Part ID
	// Max Length: 50
	PartID string `json:"part_id,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

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

InventoryItem inventory item swagger:model InventoryItem

func (*InventoryItem) MarshalBinary

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

MarshalBinary interface implementation

func (*InventoryItem) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*InventoryItem) Validate

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

Validate validates this inventory item

type Manufacturer

type Manufacturer struct {

	// Devicetype count
	// Read Only: true
	DevicetypeCount int64 `json:"devicetype_count,omitempty"`

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

	// Inventoryitem count
	// Read Only: true
	InventoryitemCount int64 `json:"inventoryitem_count,omitempty"`

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

	// Platform count
	// Read Only: true
	PlatformCount int64 `json:"platform_count,omitempty"`

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

Manufacturer manufacturer swagger:model Manufacturer

func (*Manufacturer) MarshalBinary

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

MarshalBinary interface implementation

func (*Manufacturer) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Manufacturer) Validate

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

Validate validates this manufacturer

type NestedCable

type NestedCable struct {

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

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

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

NestedCable Cable swagger:model NestedCable

func (*NestedCable) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedCable) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedCable) Validate

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

Validate validates this nested cable

type NestedCircuit

type NestedCircuit struct {

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

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

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

NestedCircuit Circuit swagger:model NestedCircuit

func (*NestedCircuit) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedCircuit) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedCircuit) Validate

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

Validate validates this nested circuit

type NestedCircuitType

type NestedCircuitType struct {

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

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

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

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

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

NestedCircuitType Type swagger:model NestedCircuitType

func (*NestedCircuitType) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedCircuitType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedCircuitType) Validate

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

Validate validates this nested circuit type

type NestedCluster

type NestedCluster struct {

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

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

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

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

NestedCluster Cluster swagger:model NestedCluster

func (*NestedCluster) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedCluster) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedCluster) Validate

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

Validate validates this nested cluster

type NestedClusterGroup

type NestedClusterGroup struct {

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

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

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

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

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

NestedClusterGroup Group swagger:model NestedClusterGroup

func (*NestedClusterGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedClusterGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedClusterGroup) Validate

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

Validate validates this nested cluster group

type NestedClusterType

type NestedClusterType struct {

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

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

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

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

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

NestedClusterType Type swagger:model NestedClusterType

func (*NestedClusterType) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedClusterType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedClusterType) Validate

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

Validate validates this nested cluster type

type NestedDevice

type NestedDevice struct {

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

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

	// Name
	// Max Length: 64
	Name *string `json:"name,omitempty"`

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

NestedDevice Device swagger:model NestedDevice

func (*NestedDevice) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedDevice) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedDevice) Validate

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

Validate validates this nested device

type NestedDeviceRole

type NestedDeviceRole struct {

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

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

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

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

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

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

NestedDeviceRole Device role swagger:model NestedDeviceRole

func (*NestedDeviceRole) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedDeviceRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedDeviceRole) Validate

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

Validate validates this nested device role

type NestedDeviceType

type NestedDeviceType struct {

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

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

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

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

	// Model
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Model *string `json:"model"`

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

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

NestedDeviceType Device type swagger:model NestedDeviceType

func (*NestedDeviceType) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedDeviceType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedDeviceType) Validate

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

Validate validates this nested device type

type NestedIPAddress

type NestedIPAddress struct {

	// Address
	//
	// IPv4 or IPv6 address (with mask)
	// Required: true
	Address *string `json:"address"`

	// Family
	// Read Only: true
	Family int64 `json:"family,omitempty"`

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

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

NestedIPAddress Primary ip swagger:model NestedIPAddress

func (*NestedIPAddress) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedIPAddress) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedIPAddress) Validate

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

Validate validates this nested IP address

type NestedInterface

type NestedInterface struct {

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

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

	// device
	Device *NestedDevice `json:"device,omitempty"`

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

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

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

NestedInterface Connected endpoint swagger:model NestedInterface

func (*NestedInterface) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedInterface) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedInterface) Validate

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

Validate validates this nested interface

type NestedInterfaceConnectionStatus

type NestedInterfaceConnectionStatus struct {

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

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

NestedInterfaceConnectionStatus Connection status swagger:model NestedInterfaceConnectionStatus

func (*NestedInterfaceConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedInterfaceConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedInterfaceConnectionStatus) Validate

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

Validate validates this nested interface connection status

type NestedManufacturer

type NestedManufacturer struct {

	// Devicetype count
	// Read Only: true
	DevicetypeCount int64 `json:"devicetype_count,omitempty"`

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

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

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

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

NestedManufacturer Manufacturer swagger:model NestedManufacturer

func (*NestedManufacturer) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedManufacturer) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedManufacturer) Validate

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

Validate validates this nested manufacturer

type NestedPlatform

type NestedPlatform struct {

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

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

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

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

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

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

NestedPlatform Platform swagger:model NestedPlatform

func (*NestedPlatform) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedPlatform) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedPlatform) Validate

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

Validate validates this nested platform

type NestedPowerPanel

type NestedPowerPanel struct {

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

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

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

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

NestedPowerPanel Power panel swagger:model NestedPowerPanel

func (*NestedPowerPanel) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedPowerPanel) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedPowerPanel) Validate

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

Validate validates this nested power panel

type NestedPowerPort

type NestedPowerPort struct {

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

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

	// device
	Device *NestedDevice `json:"device,omitempty"`

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

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

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

NestedPowerPort Power port swagger:model NestedPowerPort

func (*NestedPowerPort) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedPowerPort) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedPowerPort) Validate

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

Validate validates this nested power port

type NestedPowerPortConnectionStatus

type NestedPowerPortConnectionStatus struct {

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

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

NestedPowerPortConnectionStatus Connection status swagger:model NestedPowerPortConnectionStatus

func (*NestedPowerPortConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedPowerPortConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedPowerPortConnectionStatus) Validate

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

Validate validates this nested power port connection status

type NestedProvider

type NestedProvider struct {

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

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

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

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

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

NestedProvider Provider swagger:model NestedProvider

func (*NestedProvider) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedProvider) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedProvider) Validate

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

Validate validates this nested provider

type NestedRIR

type NestedRIR struct {

	// Aggregate count
	// Read Only: true
	AggregateCount int64 `json:"aggregate_count,omitempty"`

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

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

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

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

NestedRIR Rir swagger:model NestedRIR

func (*NestedRIR) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRIR) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRIR) Validate

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

Validate validates this nested r i r

type NestedRack

type NestedRack struct {

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

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

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

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

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

NestedRack Rack swagger:model NestedRack

func (*NestedRack) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRack) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRack) Validate

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

Validate validates this nested rack

type NestedRackGroup

type NestedRackGroup struct {

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

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

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

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

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

NestedRackGroup Rack group swagger:model NestedRackGroup

func (*NestedRackGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRackGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRackGroup) Validate

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

Validate validates this nested rack group

type NestedRackRole

type NestedRackRole struct {

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

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

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

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

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

NestedRackRole Role swagger:model NestedRackRole

func (*NestedRackRole) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRackRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRackRole) Validate

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

Validate validates this nested rack role

type NestedRearPortTemplate

type NestedRearPortTemplate struct {

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

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

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

NestedRearPortTemplate Rear port swagger:model NestedRearPortTemplate

func (*NestedRearPortTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRearPortTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRearPortTemplate) Validate

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

Validate validates this nested rear port template

type NestedRegion

type NestedRegion struct {

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

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

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

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

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

NestedRegion Parent swagger:model NestedRegion

func (*NestedRegion) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRegion) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRegion) Validate

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

Validate validates this nested region

type NestedRole

type NestedRole struct {

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

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

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

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

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

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

NestedRole Role swagger:model NestedRole

func (*NestedRole) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedRole) Validate

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

Validate validates this nested role

type NestedSecretRole

type NestedSecretRole struct {

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

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

	// Secret count
	// Read Only: true
	SecretCount int64 `json:"secret_count,omitempty"`

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

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

NestedSecretRole Role swagger:model NestedSecretRole

func (*NestedSecretRole) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedSecretRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedSecretRole) Validate

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

Validate validates this nested secret role

type NestedSite

type NestedSite struct {

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

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

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

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

NestedSite Site swagger:model NestedSite

func (*NestedSite) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedSite) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedSite) Validate

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

Validate validates this nested site

type NestedTenant

type NestedTenant struct {

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

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

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

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

NestedTenant Tenant swagger:model NestedTenant

func (*NestedTenant) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedTenant) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedTenant) Validate

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

Validate validates this nested tenant

type NestedTenantGroup

type NestedTenantGroup struct {

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

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

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

	// Tenant count
	// Read Only: true
	TenantCount int64 `json:"tenant_count,omitempty"`

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

NestedTenantGroup nested tenant group swagger:model NestedTenantGroup

func (*NestedTenantGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedTenantGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedTenantGroup) Validate

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

Validate validates this nested tenant group

type NestedUser

type NestedUser struct {

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

	// Username
	//
	// Required. 150 characters or fewer. Letters, digits and @/./+/-/_ only.
	// Required: true
	// Max Length: 150
	// Min Length: 1
	// Pattern: ^[\w.@+-]+$
	Username *string `json:"username"`
}

NestedUser User swagger:model NestedUser

func (*NestedUser) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedUser) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedUser) Validate

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

Validate validates this nested user

type NestedVLAN

type NestedVLAN struct {

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

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

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

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

	// ID
	// Required: true
	// Maximum: 4094
	// Minimum: 1
	Vid *int64 `json:"vid"`
}

NestedVLAN Untagged vlan swagger:model NestedVLAN

func (*NestedVLAN) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedVLAN) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedVLAN) Validate

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

Validate validates this nested v l a n

type NestedVLANGroup

type NestedVLANGroup struct {

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

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

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

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

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

NestedVLANGroup Group swagger:model NestedVLANGroup

func (*NestedVLANGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedVLANGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedVLANGroup) Validate

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

Validate validates this nested v l a n group

type NestedVRF

type NestedVRF struct {

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

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

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Route distinguisher
	// Max Length: 21
	Rd *string `json:"rd,omitempty"`

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

NestedVRF Vrf swagger:model NestedVRF

func (*NestedVRF) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedVRF) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedVRF) Validate

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

Validate validates this nested v r f

type NestedVirtualChassis

type NestedVirtualChassis struct {

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

	// master
	// Required: true
	Master *NestedDevice `json:"master"`

	// Member count
	// Read Only: true
	MemberCount int64 `json:"member_count,omitempty"`

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

NestedVirtualChassis Virtual chassis swagger:model NestedVirtualChassis

func (*NestedVirtualChassis) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedVirtualChassis) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedVirtualChassis) Validate

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

Validate validates this nested virtual chassis

type NestedVirtualMachine

type NestedVirtualMachine struct {

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

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

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

NestedVirtualMachine Virtual machine swagger:model NestedVirtualMachine

func (*NestedVirtualMachine) MarshalBinary

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

MarshalBinary interface implementation

func (*NestedVirtualMachine) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*NestedVirtualMachine) Validate

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

Validate validates this nested virtual machine

type ObjectChange

type ObjectChange struct {

	// action
	Action *ObjectChangeAction `json:"action,omitempty"`

	// Changed object
	//
	//
	//         Serialize a nested representation of the changed object.
	//
	// Read Only: true
	ChangedObject map[string]string `json:"changed_object,omitempty"`

	// Changed object id
	// Required: true
	// Maximum: 2.147483647e+09
	// Minimum: 0
	ChangedObjectID *int64 `json:"changed_object_id"`

	// Changed object type
	// Read Only: true
	ChangedObjectType string `json:"changed_object_type,omitempty"`

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

	// Object data
	// Read Only: true
	ObjectData string `json:"object_data,omitempty"`

	// Request id
	// Read Only: true
	// Format: uuid
	RequestID strfmt.UUID `json:"request_id,omitempty"`

	// Time
	// Read Only: true
	// Format: date-time
	Time strfmt.DateTime `json:"time,omitempty"`

	// user
	User *NestedUser `json:"user,omitempty"`

	// User name
	// Read Only: true
	// Min Length: 1
	UserName string `json:"user_name,omitempty"`
}

ObjectChange object change swagger:model ObjectChange

func (*ObjectChange) MarshalBinary

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

MarshalBinary interface implementation

func (*ObjectChange) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ObjectChange) Validate

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

Validate validates this object change

type ObjectChangeAction

type ObjectChangeAction struct {

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

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

ObjectChangeAction Action swagger:model ObjectChangeAction

func (*ObjectChangeAction) MarshalBinary

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

MarshalBinary interface implementation

func (*ObjectChangeAction) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*ObjectChangeAction) Validate

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

Validate validates this object change action

type Platform

type Platform struct {

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

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

	// manufacturer
	Manufacturer *NestedManufacturer `json:"manufacturer,omitempty"`

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

	// NAPALM arguments
	//
	// Additional arguments to pass when initiating the NAPALM driver (JSON format)
	NapalmArgs *string `json:"napalm_args,omitempty"`

	// NAPALM driver
	//
	// The name of the NAPALM driver to use when interacting with devices
	// Max Length: 50
	NapalmDriver string `json:"napalm_driver,omitempty"`

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

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

Platform platform swagger:model Platform

func (*Platform) MarshalBinary

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

MarshalBinary interface implementation

func (*Platform) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Platform) Validate

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

Validate validates this platform

type PowerFeed

type PowerFeed struct {

	// Amperage
	// Maximum: 32767
	// Minimum: 1
	Amperage int64 `json:"amperage,omitempty"`

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

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

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

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

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

	// Max utilization
	//
	// Maximum permissible draw (percentage)
	// Maximum: 100
	// Minimum: 1
	MaxUtilization int64 `json:"max_utilization,omitempty"`

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

	// phase
	Phase *PowerFeedPhase `json:"phase,omitempty"`

	// power panel
	// Required: true
	PowerPanel *NestedPowerPanel `json:"power_panel"`

	// rack
	Rack *NestedRack `json:"rack,omitempty"`

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

	// supply
	Supply *PowerFeedSupply `json:"supply,omitempty"`

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

	// type
	Type *PowerFeedType `json:"type,omitempty"`

	// Voltage
	// Maximum: 32767
	// Minimum: 1
	Voltage int64 `json:"voltage,omitempty"`
}

PowerFeed power feed swagger:model PowerFeed

func (*PowerFeed) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerFeed) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerFeed) Validate

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

Validate validates this power feed

type PowerFeedPhase

type PowerFeedPhase struct {

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

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

PowerFeedPhase Phase swagger:model PowerFeedPhase

func (*PowerFeedPhase) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerFeedPhase) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerFeedPhase) UnmarshalJSON

func (m *PowerFeedPhase) UnmarshalJSON(b []byte) error

func (*PowerFeedPhase) Validate

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

Validate validates this power feed phase

type PowerFeedStatus

type PowerFeedStatus struct {

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

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

PowerFeedStatus Status swagger:model PowerFeedStatus

func (*PowerFeedStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerFeedStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerFeedStatus) UnmarshalJSON

func (m *PowerFeedStatus) UnmarshalJSON(b []byte) error

func (*PowerFeedStatus) Validate

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

Validate validates this power feed status

type PowerFeedSupply

type PowerFeedSupply struct {

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

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

PowerFeedSupply Supply swagger:model PowerFeedSupply

func (*PowerFeedSupply) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerFeedSupply) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerFeedSupply) UnmarshalJSON

func (m *PowerFeedSupply) UnmarshalJSON(b []byte) error

func (*PowerFeedSupply) Validate

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

Validate validates this power feed supply

type PowerFeedType

type PowerFeedType struct {

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

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

PowerFeedType Type swagger:model PowerFeedType

func (*PowerFeedType) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerFeedType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerFeedType) UnmarshalJSON

func (m *PowerFeedType) UnmarshalJSON(b []byte) error

func (*PowerFeedType) Validate

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

Validate validates this power feed type

type PowerOutlet

type PowerOutlet struct {

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

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

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

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

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// feed leg
	FeedLeg *PowerOutletFeedLeg `json:"feed_leg,omitempty"`

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

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

	// power port
	PowerPort *NestedPowerPort `json:"power_port,omitempty"`

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

	// type
	Type *PowerOutletType `json:"type,omitempty"`
}

PowerOutlet power outlet swagger:model PowerOutlet

func (*PowerOutlet) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutlet) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutlet) Validate

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

Validate validates this power outlet

type PowerOutletConnectionStatus

type PowerOutletConnectionStatus struct {

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

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

PowerOutletConnectionStatus Connection status swagger:model PowerOutletConnectionStatus

func (*PowerOutletConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletConnectionStatus) Validate

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

Validate validates this power outlet connection status

type PowerOutletFeedLeg

type PowerOutletFeedLeg struct {

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

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

PowerOutletFeedLeg Feed leg swagger:model PowerOutletFeedLeg

func (*PowerOutletFeedLeg) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletFeedLeg) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletFeedLeg) Validate

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

Validate validates this power outlet feed leg

type PowerOutletTemplate

type PowerOutletTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// feed leg
	FeedLeg *PowerOutletTemplateFeedLeg `json:"feed_leg,omitempty"`

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

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

	// power port
	PowerPort *PowerPortTemplate `json:"power_port,omitempty"`

	// type
	Type *PowerOutletTemplateType `json:"type,omitempty"`
}

PowerOutletTemplate power outlet template swagger:model PowerOutletTemplate

func (*PowerOutletTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletTemplate) Validate

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

Validate validates this power outlet template

type PowerOutletTemplateFeedLeg

type PowerOutletTemplateFeedLeg struct {

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

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

PowerOutletTemplateFeedLeg Feed leg swagger:model PowerOutletTemplateFeedLeg

func (*PowerOutletTemplateFeedLeg) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletTemplateFeedLeg) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletTemplateFeedLeg) Validate

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

Validate validates this power outlet template feed leg

type PowerOutletTemplateType

type PowerOutletTemplateType struct {

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

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

PowerOutletTemplateType Type swagger:model PowerOutletTemplateType

func (*PowerOutletTemplateType) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletTemplateType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletTemplateType) Validate

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

Validate validates this power outlet template type

type PowerOutletType

type PowerOutletType struct {

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

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

PowerOutletType Type swagger:model PowerOutletType

func (*PowerOutletType) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerOutletType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerOutletType) Validate

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

Validate validates this power outlet type

type PowerPanel

type PowerPanel struct {

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

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

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// rack group
	RackGroup *NestedRackGroup `json:"rack_group,omitempty"`

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

PowerPanel power panel swagger:model PowerPanel

func (*PowerPanel) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPanel) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPanel) Validate

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

Validate validates this power panel

type PowerPort

type PowerPort struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

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

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

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

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

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

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

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

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

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

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

	// type
	Type *PowerPortType `json:"type,omitempty"`
}

PowerPort power port swagger:model PowerPort

func (*PowerPort) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPort) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPort) Validate

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

Validate validates this power port

type PowerPortConnectionStatus

type PowerPortConnectionStatus struct {

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

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

PowerPortConnectionStatus Connection status swagger:model PowerPortConnectionStatus

func (*PowerPortConnectionStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPortConnectionStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPortConnectionStatus) Validate

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

Validate validates this power port connection status

type PowerPortTemplate

type PowerPortTemplate struct {

	// Allocated draw
	//
	// Allocated power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	AllocatedDraw *int64 `json:"allocated_draw,omitempty"`

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

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

	// Maximum draw
	//
	// Maximum power draw (watts)
	// Maximum: 32767
	// Minimum: 1
	MaximumDraw *int64 `json:"maximum_draw,omitempty"`

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

	// type
	Type *PowerPortTemplateType `json:"type,omitempty"`
}

PowerPortTemplate Power port swagger:model PowerPortTemplate

func (*PowerPortTemplate) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPortTemplate) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPortTemplate) Validate

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

Validate validates this power port template

type PowerPortTemplateType

type PowerPortTemplateType struct {

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

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

PowerPortTemplateType Type swagger:model PowerPortTemplateType

func (*PowerPortTemplateType) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPortTemplateType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPortTemplateType) Validate

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

Validate validates this power port template type

type PowerPortType

type PowerPortType struct {

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

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

PowerPortType Type swagger:model PowerPortType

func (*PowerPortType) MarshalBinary

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

MarshalBinary interface implementation

func (*PowerPortType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PowerPortType) Validate

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

Validate validates this power port type

type Prefix

type Prefix struct {

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

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

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

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

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

	// Is a pool
	//
	// All IP addresses within this prefix are considered usable
	IsPool bool `json:"is_pool,omitempty"`

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

	// Prefix
	//
	// IPv4 or IPv6 network with mask
	// Required: true
	Prefix *string `json:"prefix"`

	// role
	Role *NestedRole `json:"role,omitempty"`

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

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

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

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

	// vlan
	Vlan *NestedVLAN `json:"vlan,omitempty"`

	// vrf
	Vrf *NestedVRF `json:"vrf,omitempty"`
}

Prefix prefix swagger:model Prefix

func (*Prefix) MarshalBinary

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

MarshalBinary interface implementation

func (*Prefix) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Prefix) Validate

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

Validate validates this prefix

type PrefixFamily

type PrefixFamily struct {

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

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

PrefixFamily Family swagger:model PrefixFamily

func (*PrefixFamily) MarshalBinary

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

MarshalBinary interface implementation

func (*PrefixFamily) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PrefixFamily) Validate

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

Validate validates this prefix family

type PrefixStatus

type PrefixStatus struct {

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

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

PrefixStatus Status swagger:model PrefixStatus

func (*PrefixStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*PrefixStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*PrefixStatus) Validate

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

Validate validates this prefix status

type Provider

type Provider struct {

	// Account number
	// Max Length: 30
	Account string `json:"account,omitempty"`

	// Admin contact
	AdminContact string `json:"admin_contact,omitempty"`

	// ASN
	// Maximum: 4.294967295e+09
	// Minimum: 1
	Asn *int64 `json:"asn,omitempty"`

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

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

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

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

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

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

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

	// NOC contact
	NocContact string `json:"noc_contact,omitempty"`

	// Portal
	// Max Length: 200
	// Format: uri
	PortalURL strfmt.URI `json:"portal_url,omitempty"`

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

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

Provider provider swagger:model Provider

func (*Provider) MarshalBinary

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

MarshalBinary interface implementation

func (*Provider) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Provider) Validate

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

Validate validates this provider

type RIR

type RIR struct {

	// Aggregate count
	// Read Only: true
	AggregateCount int64 `json:"aggregate_count,omitempty"`

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

	// Private
	//
	// IP space managed by this RIR is considered private
	IsPrivate bool `json:"is_private,omitempty"`

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

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

RIR r i r swagger:model RIR

func (*RIR) MarshalBinary

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

MarshalBinary interface implementation

func (*RIR) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RIR) Validate

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

Validate validates this r i r

type Rack

type Rack struct {

	// Asset tag
	//
	// A unique tag used to identify this rack
	// Max Length: 50
	AssetTag *string `json:"asset_tag,omitempty"`

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

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

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

	// Descending units
	//
	// Units are numbered top-to-bottom
	DescUnits bool `json:"desc_units,omitempty"`

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

	// Display name
	// Read Only: true
	DisplayName string `json:"display_name,omitempty"`

	// Facility ID
	// Max Length: 50
	FacilityID *string `json:"facility_id,omitempty"`

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

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

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

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

	// Outer depth
	// Maximum: 32767
	// Minimum: 0
	OuterDepth *int64 `json:"outer_depth,omitempty"`

	// outer unit
	OuterUnit *RackOuterUnit `json:"outer_unit,omitempty"`

	// Outer width
	// Maximum: 32767
	// Minimum: 0
	OuterWidth *int64 `json:"outer_width,omitempty"`

	// Powerfeed count
	// Read Only: true
	PowerfeedCount int64 `json:"powerfeed_count,omitempty"`

	// role
	Role *NestedRackRole `json:"role,omitempty"`

	// Serial number
	// Max Length: 50
	Serial string `json:"serial,omitempty"`

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

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

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

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

	// type
	Type *RackType `json:"type,omitempty"`

	// Height (U)
	// Maximum: 100
	// Minimum: 1
	UHeight int64 `json:"u_height,omitempty"`

	// width
	Width *RackWidth `json:"width,omitempty"`
}

Rack rack swagger:model Rack

func (*Rack) MarshalBinary

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

MarshalBinary interface implementation

func (*Rack) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*Rack) Validate

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

Validate validates this rack

type RackGroup

type RackGroup struct {

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

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

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

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

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

RackGroup rack group swagger:model RackGroup

func (*RackGroup) MarshalBinary

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

MarshalBinary interface implementation

func (*RackGroup) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackGroup) Validate

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

Validate validates this rack group

type RackOuterUnit

type RackOuterUnit struct {

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

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

RackOuterUnit Outer unit swagger:model RackOuterUnit

func (*RackOuterUnit) MarshalBinary

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

MarshalBinary interface implementation

func (*RackOuterUnit) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackOuterUnit) Validate

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

Validate validates this rack outer unit

type RackReservation

type RackReservation struct {

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

	// Description
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Description *string `json:"description"`

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

	// rack
	// Required: true
	Rack *NestedRack `json:"rack"`

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

	// units
	// Required: true
	Units []*int64 `json:"units"`

	// user
	// Required: true
	User *NestedUser `json:"user"`
}

RackReservation rack reservation swagger:model RackReservation

func (*RackReservation) MarshalBinary

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

MarshalBinary interface implementation

func (*RackReservation) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackReservation) Validate

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

Validate validates this rack reservation

type RackRole

type RackRole struct {

	// Color
	// Required: true
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color *string `json:"color"`

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

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

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

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

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

RackRole rack role swagger:model RackRole

func (*RackRole) MarshalBinary

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

MarshalBinary interface implementation

func (*RackRole) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackRole) Validate

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

Validate validates this rack role

type RackStatus

type RackStatus struct {

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

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

RackStatus Status swagger:model RackStatus

func (*RackStatus) MarshalBinary

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

MarshalBinary interface implementation

func (*RackStatus) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackStatus) Validate

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

Validate validates this rack status

type RackType

type RackType struct {

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

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

RackType Type swagger:model RackType

func (*RackType) MarshalBinary

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

MarshalBinary interface implementation

func (*RackType) UnmarshalBinary

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

UnmarshalBinary interface implementation

func (*RackType) Validate

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

Validate validates this rack type

type RackUnit

type RackUnit struct {

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// face
	Face *RackUnitFace `json:"face,omitempty"`

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

	// Name
	// Read Only: true
	// Min Length: 1
	Name string `json:"name,omitempty"`
}

RackUnit rack unit swagger:model RackUnit

func (*RackUnit) MarshalBinary

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

MarshalBinary interface implementation

func (*RackUnit) UnmarshalBinary

func (m *RackUnit) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackUnit) Validate

func (m *RackUnit) Validate(formats strfmt.Registry) error

Validate validates this rack unit

type RackUnitFace

type RackUnitFace struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackUnitFace Face swagger:model RackUnitFace

func (*RackUnitFace) MarshalBinary

func (m *RackUnitFace) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackUnitFace) UnmarshalBinary

func (m *RackUnitFace) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackUnitFace) Validate

func (m *RackUnitFace) Validate(formats strfmt.Registry) error

Validate validates this rack unit face

type RackWidth

type RackWidth struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RackWidth Width swagger:model RackWidth

func (*RackWidth) MarshalBinary

func (m *RackWidth) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RackWidth) UnmarshalBinary

func (m *RackWidth) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RackWidth) Validate

func (m *RackWidth) Validate(formats strfmt.Registry) error

Validate validates this rack width

type RearPort

type RearPort struct {

	// cable
	Cable *NestedCable `json:"cable,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// type
	// Required: true
	Type *RearPortType `json:"type"`
}

RearPort rear port swagger:model RearPort

func (*RearPort) MarshalBinary

func (m *RearPort) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPort) UnmarshalBinary

func (m *RearPort) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPort) Validate

func (m *RearPort) Validate(formats strfmt.Registry) error

Validate validates this rear port

type RearPortTemplate

type RearPortTemplate struct {

	// device type
	// Required: true
	DeviceType *NestedDeviceType `json:"device_type"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 64
	// Min Length: 1
	Name *string `json:"name"`

	// Positions
	// Maximum: 64
	// Minimum: 1
	Positions int64 `json:"positions,omitempty"`

	// type
	// Required: true
	Type *RearPortTemplateType `json:"type"`
}

RearPortTemplate rear port template swagger:model RearPortTemplate

func (*RearPortTemplate) MarshalBinary

func (m *RearPortTemplate) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortTemplate) UnmarshalBinary

func (m *RearPortTemplate) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortTemplate) Validate

func (m *RearPortTemplate) Validate(formats strfmt.Registry) error

Validate validates this rear port template

type RearPortTemplateType

type RearPortTemplateType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RearPortTemplateType Type swagger:model RearPortTemplateType

func (*RearPortTemplateType) MarshalBinary

func (m *RearPortTemplateType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortTemplateType) UnmarshalBinary

func (m *RearPortTemplateType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortTemplateType) Validate

func (m *RearPortTemplateType) Validate(formats strfmt.Registry) error

Validate validates this rear port template type

type RearPortType

type RearPortType struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

RearPortType Type swagger:model RearPortType

func (*RearPortType) MarshalBinary

func (m *RearPortType) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*RearPortType) UnmarshalBinary

func (m *RearPortType) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*RearPortType) Validate

func (m *RearPortType) Validate(formats strfmt.Registry) error

Validate validates this rear port type

type Region

type Region struct {

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// parent
	Parent *NestedRegion `json:"parent,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

Region region swagger:model Region

func (*Region) MarshalBinary

func (m *Region) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Region) UnmarshalBinary

func (m *Region) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Region) Validate

func (m *Region) Validate(formats strfmt.Registry) error

Validate validates this region

type Role

type Role struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`

	// Weight
	// Maximum: 32767
	// Minimum: 0
	Weight *int64 `json:"weight,omitempty"`
}

Role role swagger:model Role

func (*Role) MarshalBinary

func (m *Role) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Role) UnmarshalBinary

func (m *Role) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Role) Validate

func (m *Role) Validate(formats strfmt.Registry) error

Validate validates this role

type Secret

type Secret struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// device
	// Required: true
	Device *NestedDevice `json:"device"`

	// Hash
	// Read Only: true
	// Min Length: 1
	Hash string `json:"hash,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Max Length: 100
	Name string `json:"name,omitempty"`

	// Plaintext
	// Required: true
	// Min Length: 1
	Plaintext *string `json:"plaintext"`

	// role
	// Required: true
	Role *NestedSecretRole `json:"role"`

	// tags
	Tags []string `json:"tags"`
}

Secret secret swagger:model Secret

func (*Secret) MarshalBinary

func (m *Secret) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Secret) UnmarshalBinary

func (m *Secret) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Secret) Validate

func (m *Secret) Validate(formats strfmt.Registry) error

Validate validates this secret

type SecretRole

type SecretRole struct {

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Secret count
	// Read Only: true
	SecretCount int64 `json:"secret_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`
}

SecretRole secret role swagger:model SecretRole

func (*SecretRole) MarshalBinary

func (m *SecretRole) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SecretRole) UnmarshalBinary

func (m *SecretRole) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SecretRole) Validate

func (m *SecretRole) Validate(formats strfmt.Registry) error

Validate validates this secret role

type Service

type Service struct {

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// device
	Device *NestedDevice `json:"device,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// ipaddresses
	// Unique: true
	Ipaddresses []*NestedIPAddress `json:"ipaddresses"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Port number
	// Required: true
	// Maximum: 65535
	// Minimum: 1
	Port *int64 `json:"port"`

	// protocol
	// Required: true
	Protocol *ServiceProtocol `json:"protocol"`

	// virtual machine
	VirtualMachine *NestedVirtualMachine `json:"virtual_machine,omitempty"`
}

Service service swagger:model Service

func (*Service) MarshalBinary

func (m *Service) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Service) UnmarshalBinary

func (m *Service) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Service) Validate

func (m *Service) Validate(formats strfmt.Registry) error

Validate validates this service

type ServiceProtocol

type ServiceProtocol struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

ServiceProtocol Protocol swagger:model ServiceProtocol

func (*ServiceProtocol) MarshalBinary

func (m *ServiceProtocol) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*ServiceProtocol) UnmarshalBinary

func (m *ServiceProtocol) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*ServiceProtocol) Validate

func (m *ServiceProtocol) Validate(formats strfmt.Registry) error

Validate validates this service protocol

type Site

type Site struct {

	// ASN
	// Maximum: 4.294967295e+09
	// Minimum: 1
	Asn *int64 `json:"asn,omitempty"`

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Contact E-mail
	// Max Length: 254
	// Format: email
	ContactEmail strfmt.Email `json:"contact_email,omitempty"`

	// Contact name
	// Max Length: 50
	ContactName string `json:"contact_name,omitempty"`

	// Contact phone
	// Max Length: 20
	ContactPhone string `json:"contact_phone,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// Facility
	// Max Length: 50
	Facility string `json:"facility,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Latitude
	Latitude *string `json:"latitude,omitempty"`

	// Longitude
	Longitude *string `json:"longitude,omitempty"`

	// Name
	// Required: true
	// Max Length: 50
	// Min Length: 1
	Name *string `json:"name"`

	// Physical address
	// Max Length: 200
	PhysicalAddress string `json:"physical_address,omitempty"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// region
	Region *NestedRegion `json:"region,omitempty"`

	// Shipping address
	// Max Length: 200
	ShippingAddress string `json:"shipping_address,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// status
	Status *SiteStatus `json:"status,omitempty"`

	// tags
	Tags []string `json:"tags"`

	// tenant
	Tenant *NestedTenant `json:"tenant,omitempty"`

	// Time zone
	TimeZone string `json:"time_zone,omitempty"`

	// Virtualmachine count
	// Read Only: true
	VirtualmachineCount int64 `json:"virtualmachine_count,omitempty"`

	// Vlan count
	// Read Only: true
	VlanCount int64 `json:"vlan_count,omitempty"`
}

Site site swagger:model Site

func (*Site) MarshalBinary

func (m *Site) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Site) UnmarshalBinary

func (m *Site) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Site) Validate

func (m *Site) Validate(formats strfmt.Registry) error

Validate validates this site

type SiteStatus

type SiteStatus struct {

	// label
	// Required: true
	Label *string `json:"label"`

	// value
	// Required: true
	Value *string `json:"value"`
}

SiteStatus Status swagger:model SiteStatus

func (*SiteStatus) MarshalBinary

func (m *SiteStatus) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*SiteStatus) UnmarshalBinary

func (m *SiteStatus) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*SiteStatus) Validate

func (m *SiteStatus) Validate(formats strfmt.Registry) error

Validate validates this site status

type Tag

type Tag struct {

	// Color
	// Max Length: 6
	// Min Length: 1
	// Pattern: ^[0-9a-f]{6}$
	Color string `json:"color,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Name
	// Required: true
	// Max Length: 100
	// Min Length: 1
	Name *string `json:"name"`

	// Slug
	// Required: true
	// Max Length: 100
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// Tagged items
	// Read Only: true
	TaggedItems int64 `json:"tagged_items,omitempty"`
}

Tag tag swagger:model Tag

func (*Tag) MarshalBinary

func (m *Tag) MarshalBinary() ([]byte, error)

MarshalBinary interface implementation

func (*Tag) UnmarshalBinary

func (m *Tag) UnmarshalBinary(b []byte) error

UnmarshalBinary interface implementation

func (*Tag) Validate

func (m *Tag) Validate(formats strfmt.Registry) error

Validate validates this tag

type Tenant

type Tenant struct {

	// Circuit count
	// Read Only: true
	CircuitCount int64 `json:"circuit_count,omitempty"`

	// Cluster count
	// Read Only: true
	ClusterCount int64 `json:"cluster_count,omitempty"`

	// Comments
	Comments string `json:"comments,omitempty"`

	// Created
	// Read Only: true
	// Format: date
	Created strfmt.Date `json:"created,omitempty"`

	// Custom fields
	CustomFields interface{} `json:"custom_fields,omitempty"`

	// Description
	//
	// Long-form name (optional)
	// Max Length: 100
	Description string `json:"description,omitempty"`

	// Device count
	// Read Only: true
	DeviceCount int64 `json:"device_count,omitempty"`

	// group
	Group *NestedTenantGroup `json:"group,omitempty"`

	// ID
	// Read Only: true
	ID int64 `json:"id,omitempty"`

	// Ipaddress count
	// Read Only: true
	IpaddressCount int64 `json:"ipaddress_count,omitempty"`

	// Last updated
	// Read Only: true
	// Format: date-time
	LastUpdated strfmt.DateTime `json:"last_updated,omitempty"`

	// Name
	// Required: true
	// Max Length: 30
	// Min Length: 1
	Name *string `json:"name"`

	// Prefix count
	// Read Only: true
	PrefixCount int64 `json:"prefix_count,omitempty"`

	// Rack count
	// Read Only: true
	RackCount int64 `json:"rack_count,omitempty"`

	// Site count
	// Read Only: true
	SiteCount int64 `json:"site_count,omitempty"`

	// Slug
	// Required: true
	// Max Length: 50
	// Min Length: 1
	// Pattern: ^[-a-zA-Z0-9_]+$
	Slug *string `json:"slug"`

	// tags
	Tags []string `json: