Documentation

Overview

    A Pulumi package for creating and managing equinix-metal cloud resources.

    Index

    Constants

    View Source
    const (
    	BillingCycleHourly  = BillingCycle("hourly")
    	BillingCycleMonthly = BillingCycle("monthly")
    )
    View Source
    const (
    	FacilityEWR1 = Facility("ewr1")
    	FacilitySJC1 = Facility("sjc1")
    	FacilityDFW1 = Facility("dfw1")
    	FacilityDFW2 = Facility("dfw2")
    	FacilityAMS1 = Facility("ams1")
    	FacilityNRT1 = Facility("nrt1")
    	FacilitySEA1 = Facility("sea1")
    	FacilityLAX1 = Facility("lax1")
    	FacilityORD1 = Facility("ord1")
    	FacilityATL1 = Facility("atl1")
    	FacilityIAD1 = Facility("iad1")
    	FacilitySIN1 = Facility("sin1")
    	FacilityHKG1 = Facility("hkg1")
    	FacilitySYD1 = Facility("syd1")
    	FacilityMRS1 = Facility("mrs1")
    	FacilityYYZ1 = Facility("yyz1")
    	FacilityFRA2 = Facility("fra2")
    	FacilityAM6  = Facility("am6")
    	FacilityDC13 = Facility("dc13")
    	FacilityCH3  = Facility("ch3")
    	FacilityDA3  = Facility("da3")
    	FacilityDA11 = Facility("da11")
    	FacilityLA4  = Facility("la4")
    	FacilityNY5  = Facility("ny5")
    	FacilitySG1  = Facility("sg1")
    	FacilitySV15 = Facility("sv15")
    )
    View Source
    const (
    	IpBlockTypeGlobalIPv4 = IpBlockType("global_ipv4")
    	IpBlockTypePublicIPv4 = IpBlockType("public_ipv4")
    )
    View Source
    const (
    	NetworkTypeLayer3           = NetworkType("layer3")
    	NetworkTypeLayer2Individual = NetworkType("layer2-individual")
    	NetworkTypeLayer2Bonded     = NetworkType("layer2-bonded")
    	NetworkTypeHybrid           = NetworkType("hybrid")
    )
    View Source
    const (
    	OperatingSystemAlpine3          = OperatingSystem("alpine_3")
    	OperatingSystemCentOS6          = OperatingSystem("centos_6")
    	OperatingSystemCentOS7          = OperatingSystem("centos_7")
    	OperatingSystemCentOS8          = OperatingSystem("centos_8")
    	OperatingSystemCoreOSAlpha      = OperatingSystem("coreos_alpha")
    	OperatingSystemCoreOSBeta       = OperatingSystem("coreos_beta")
    	OperatingSystemCoreOSStable     = OperatingSystem("coreos_stable")
    	OperatingSystemCustomIPXE       = OperatingSystem("custom_ipxe")
    	OperatingSystemDebian8          = OperatingSystem("debian_8")
    	OperatingSystemDebian9          = OperatingSystem("debian_9")
    	OperatingSystemDebian10         = OperatingSystem("debian_10")
    	OperatingSystemFlatcarAlpha     = OperatingSystem("flatcar_alpha")
    	OperatingSystemFlatcarBeta      = OperatingSystem("flatcar_beta")
    	OperatingSystemFlatcarEdge      = OperatingSystem("flatcar_edge")
    	OperatingSystemFlatcarStable    = OperatingSystem("flatcar_stable")
    	OperatingSystem_FreeBSD10_4     = OperatingSystem("freebsd_10_4")
    	OperatingSystem_FreeBSD11_1     = OperatingSystem("freebsd_11_1")
    	OperatingSystem_FreeBSD11_2     = OperatingSystem("freebsd_11_2")
    	OperatingSystemFreeBSD12Testing = OperatingSystem("freebsd_12_testing")
    	OperatingSystem_NixOS18_03      = OperatingSystem("nixos_18_03")
    	OperatingSystem_NixOS19_03      = OperatingSystem("nixos_19_03")
    	OperatingSystem_OpenSUSE42_3    = OperatingSystem("opensuse_42_3")
    	OperatingSystemRancherOS        = OperatingSystem("rancher")
    	OperatingSystemRHEL7            = OperatingSystem("rhel_7")
    	OperatingSystemRHEL8            = OperatingSystem("rhel_8")
    	OperatingSystemScientificLinux6 = OperatingSystem("scientific_6")
    	OperatingSystemSLES12SP3        = OperatingSystem("suse_sles12_sp3")
    	OperatingSystemUbuntu1404       = OperatingSystem("ubuntu_14_04")
    	OperatingSystemUbuntu1604       = OperatingSystem("ubuntu_16_04")
    	OperatingSystemUbuntu1710       = OperatingSystem("ubuntu_17_10")
    	OperatingSystemUbuntu1804       = OperatingSystem("ubuntu_18_04")
    	OperatingSystemUbuntu2004       = OperatingSystem("ubuntu_20_04")
    	OperatingSystemUbuntu2010       = OperatingSystem("ubuntu_20_10")
    	OperatingSystem_VMWareEsxi6_5   = OperatingSystem("vmware_esxi_6_5")
    	OperatingSystem_VMWareEsxi6_7   = OperatingSystem("vmware_esxi_6_7")
    	OperatingSystem_VMWareEsxi7_0   = OperatingSystem("vmware_esxi_7_0")
    	OperatingSystemWindows2012R2    = OperatingSystem("windows_2012_r2")
    	OperatingSystemWindows2016      = OperatingSystem("windows_2016")
    	OperatingSystemWindows2019      = OperatingSystem("windows_2019")
    )
    View Source
    const (
    	PlanC2LargeARM  = Plan("c2.large.arm")
    	PlanC2MediumX86 = Plan("c2.medium.x86")
    	PlanC1SmallX86  = Plan("baremetal_1")
    	PlanC1LargeARM  = Plan("baremetal_2a")
    	PlanC1XLargeX86 = Plan("baremetal_3")
    	PlanX2XLargeX86 = Plan("x2.xlarge.x86")
    	PlanX1SmallX86  = Plan("baremetal_1e")
    	PlanG2LargeX86  = Plan("g2.large.x86")
    	PlanM2XLargeX86 = Plan("m2.xlarge.x86")
    	PlanM1XLargeX86 = Plan("baremetal_2")
    	PlanT1SmallX86  = Plan("baremetal_0")
    	PlanS1LargeX86  = Plan("baremetal_s")
    	PlanC3SmallX86  = Plan("c3.small.x86")
    	PlanC3MediumX86 = Plan("c3.medium.x86")
    	PlanF3MediumX86 = Plan("f3.medium.x86")
    	PlanF3LargeX86  = Plan("f3.large.x86")
    	PlanM3LargeX86  = Plan("m3.large.x86")
    	PlanS3XLargeX86 = Plan("s3.xlarge.x86")
    	PlanN2XLargeX86 = Plan("n2.xlarge.x86")
    )

    Variables

    This section is empty.

    Functions

    func PkgVersion

    func PkgVersion() (semver.Version, error)

      PkgVersion uses reflection to determine the version of the current package.

      Types

      type BgpSession

      type BgpSession struct {
      	pulumi.CustomResourceState
      
      	// `ipv4` or `ipv6`
      	AddressFamily pulumi.StringOutput `pulumi:"addressFamily"`
      	// Boolean flag to set the default route policy. False by default.
      	DefaultRoute pulumi.BoolPtrOutput `pulumi:"defaultRoute"`
      	// ID of device
      	DeviceId pulumi.StringOutput `pulumi:"deviceId"`
      	Status   pulumi.StringOutput `pulumi:"status"`
      }

        Provides a resource to manage BGP sessions in Equinix Metal Host. Refer to [Equinix Metal BGP documentation](https://metal.equinix.com/developers/docs/networking/local-global-bgp/) for more details.

        You need to have BGP config enabled in your project.

        BGP session must be linked to a device running [BIRD](https://bird.network.cz) or other BGP routing daemon which will control route advertisements via the session to Equinix Metal's upstream routers.

        func GetBgpSession

        func GetBgpSession(ctx *pulumi.Context,
        	name string, id pulumi.IDInput, state *BgpSessionState, opts ...pulumi.ResourceOption) (*BgpSession, error)

          GetBgpSession gets an existing BgpSession resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

          func NewBgpSession

          func NewBgpSession(ctx *pulumi.Context,
          	name string, args *BgpSessionArgs, opts ...pulumi.ResourceOption) (*BgpSession, error)

            NewBgpSession registers a new resource with the given unique name, arguments, and options.

            func (*BgpSession) ElementType

            func (*BgpSession) ElementType() reflect.Type

            func (*BgpSession) ToBgpSessionOutput

            func (i *BgpSession) ToBgpSessionOutput() BgpSessionOutput

            func (*BgpSession) ToBgpSessionOutputWithContext

            func (i *BgpSession) ToBgpSessionOutputWithContext(ctx context.Context) BgpSessionOutput

            func (*BgpSession) ToBgpSessionPtrOutput

            func (i *BgpSession) ToBgpSessionPtrOutput() BgpSessionPtrOutput

            func (*BgpSession) ToBgpSessionPtrOutputWithContext

            func (i *BgpSession) ToBgpSessionPtrOutputWithContext(ctx context.Context) BgpSessionPtrOutput

            type BgpSessionArgs

            type BgpSessionArgs struct {
            	// `ipv4` or `ipv6`
            	AddressFamily pulumi.StringInput
            	// Boolean flag to set the default route policy. False by default.
            	DefaultRoute pulumi.BoolPtrInput
            	// ID of device
            	DeviceId pulumi.StringInput
            }

              The set of arguments for constructing a BgpSession resource.

              func (BgpSessionArgs) ElementType

              func (BgpSessionArgs) ElementType() reflect.Type

              type BgpSessionArray

              type BgpSessionArray []BgpSessionInput

              func (BgpSessionArray) ElementType

              func (BgpSessionArray) ElementType() reflect.Type

              func (BgpSessionArray) ToBgpSessionArrayOutput

              func (i BgpSessionArray) ToBgpSessionArrayOutput() BgpSessionArrayOutput

              func (BgpSessionArray) ToBgpSessionArrayOutputWithContext

              func (i BgpSessionArray) ToBgpSessionArrayOutputWithContext(ctx context.Context) BgpSessionArrayOutput

              type BgpSessionArrayInput

              type BgpSessionArrayInput interface {
              	pulumi.Input
              
              	ToBgpSessionArrayOutput() BgpSessionArrayOutput
              	ToBgpSessionArrayOutputWithContext(context.Context) BgpSessionArrayOutput
              }

                BgpSessionArrayInput is an input type that accepts BgpSessionArray and BgpSessionArrayOutput values. You can construct a concrete instance of `BgpSessionArrayInput` via:

                BgpSessionArray{ BgpSessionArgs{...} }
                

                type BgpSessionArrayOutput

                type BgpSessionArrayOutput struct{ *pulumi.OutputState }

                func (BgpSessionArrayOutput) ElementType

                func (BgpSessionArrayOutput) ElementType() reflect.Type

                func (BgpSessionArrayOutput) Index

                func (BgpSessionArrayOutput) ToBgpSessionArrayOutput

                func (o BgpSessionArrayOutput) ToBgpSessionArrayOutput() BgpSessionArrayOutput

                func (BgpSessionArrayOutput) ToBgpSessionArrayOutputWithContext

                func (o BgpSessionArrayOutput) ToBgpSessionArrayOutputWithContext(ctx context.Context) BgpSessionArrayOutput

                type BgpSessionInput

                type BgpSessionInput interface {
                	pulumi.Input
                
                	ToBgpSessionOutput() BgpSessionOutput
                	ToBgpSessionOutputWithContext(ctx context.Context) BgpSessionOutput
                }

                type BgpSessionMap

                type BgpSessionMap map[string]BgpSessionInput

                func (BgpSessionMap) ElementType

                func (BgpSessionMap) ElementType() reflect.Type

                func (BgpSessionMap) ToBgpSessionMapOutput

                func (i BgpSessionMap) ToBgpSessionMapOutput() BgpSessionMapOutput

                func (BgpSessionMap) ToBgpSessionMapOutputWithContext

                func (i BgpSessionMap) ToBgpSessionMapOutputWithContext(ctx context.Context) BgpSessionMapOutput

                type BgpSessionMapInput

                type BgpSessionMapInput interface {
                	pulumi.Input
                
                	ToBgpSessionMapOutput() BgpSessionMapOutput
                	ToBgpSessionMapOutputWithContext(context.Context) BgpSessionMapOutput
                }

                  BgpSessionMapInput is an input type that accepts BgpSessionMap and BgpSessionMapOutput values. You can construct a concrete instance of `BgpSessionMapInput` via:

                  BgpSessionMap{ "key": BgpSessionArgs{...} }
                  

                  type BgpSessionMapOutput

                  type BgpSessionMapOutput struct{ *pulumi.OutputState }

                  func (BgpSessionMapOutput) ElementType

                  func (BgpSessionMapOutput) ElementType() reflect.Type

                  func (BgpSessionMapOutput) MapIndex

                  func (BgpSessionMapOutput) ToBgpSessionMapOutput

                  func (o BgpSessionMapOutput) ToBgpSessionMapOutput() BgpSessionMapOutput

                  func (BgpSessionMapOutput) ToBgpSessionMapOutputWithContext

                  func (o BgpSessionMapOutput) ToBgpSessionMapOutputWithContext(ctx context.Context) BgpSessionMapOutput

                  type BgpSessionOutput

                  type BgpSessionOutput struct {
                  	*pulumi.OutputState
                  }

                  func (BgpSessionOutput) ElementType

                  func (BgpSessionOutput) ElementType() reflect.Type

                  func (BgpSessionOutput) ToBgpSessionOutput

                  func (o BgpSessionOutput) ToBgpSessionOutput() BgpSessionOutput

                  func (BgpSessionOutput) ToBgpSessionOutputWithContext

                  func (o BgpSessionOutput) ToBgpSessionOutputWithContext(ctx context.Context) BgpSessionOutput

                  func (BgpSessionOutput) ToBgpSessionPtrOutput

                  func (o BgpSessionOutput) ToBgpSessionPtrOutput() BgpSessionPtrOutput

                  func (BgpSessionOutput) ToBgpSessionPtrOutputWithContext

                  func (o BgpSessionOutput) ToBgpSessionPtrOutputWithContext(ctx context.Context) BgpSessionPtrOutput

                  type BgpSessionPtrInput

                  type BgpSessionPtrInput interface {
                  	pulumi.Input
                  
                  	ToBgpSessionPtrOutput() BgpSessionPtrOutput
                  	ToBgpSessionPtrOutputWithContext(ctx context.Context) BgpSessionPtrOutput
                  }

                  type BgpSessionPtrOutput

                  type BgpSessionPtrOutput struct {
                  	*pulumi.OutputState
                  }

                  func (BgpSessionPtrOutput) ElementType

                  func (BgpSessionPtrOutput) ElementType() reflect.Type

                  func (BgpSessionPtrOutput) ToBgpSessionPtrOutput

                  func (o BgpSessionPtrOutput) ToBgpSessionPtrOutput() BgpSessionPtrOutput

                  func (BgpSessionPtrOutput) ToBgpSessionPtrOutputWithContext

                  func (o BgpSessionPtrOutput) ToBgpSessionPtrOutputWithContext(ctx context.Context) BgpSessionPtrOutput

                  type BgpSessionState

                  type BgpSessionState struct {
                  	// `ipv4` or `ipv6`
                  	AddressFamily pulumi.StringPtrInput
                  	// Boolean flag to set the default route policy. False by default.
                  	DefaultRoute pulumi.BoolPtrInput
                  	// ID of device
                  	DeviceId pulumi.StringPtrInput
                  	Status   pulumi.StringPtrInput
                  }

                  func (BgpSessionState) ElementType

                  func (BgpSessionState) ElementType() reflect.Type

                  type BillingCycle

                  type BillingCycle pulumi.String

                  func (BillingCycle) ElementType

                  func (BillingCycle) ElementType() reflect.Type

                  func (BillingCycle) ToStringOutput

                  func (e BillingCycle) ToStringOutput() pulumi.StringOutput

                  func (BillingCycle) ToStringOutputWithContext

                  func (e BillingCycle) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

                  func (BillingCycle) ToStringPtrOutput

                  func (e BillingCycle) ToStringPtrOutput() pulumi.StringPtrOutput

                  func (BillingCycle) ToStringPtrOutputWithContext

                  func (e BillingCycle) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

                  type Device

                  type Device struct {
                  	pulumi.CustomResourceState
                  
                  	// The ipv4 private IP assigned to the device
                  	AccessPrivateIpv4 pulumi.StringOutput `pulumi:"accessPrivateIpv4"`
                  	// The ipv4 maintenance IP assigned to the device
                  	AccessPublicIpv4 pulumi.StringOutput `pulumi:"accessPublicIpv4"`
                  	// The ipv6 maintenance IP assigned to the device
                  	AccessPublicIpv6 pulumi.StringOutput `pulumi:"accessPublicIpv6"`
                  	// If true, a device with OS `customIpxe` will
                  	// continue to boot via iPXE on reboots.
                  	AlwaysPxe pulumi.BoolPtrOutput `pulumi:"alwaysPxe"`
                  	// monthly or hourly
                  	BillingCycle pulumi.StringOutput `pulumi:"billingCycle"`
                  	// The timestamp for when the device was created
                  	Created pulumi.StringOutput `pulumi:"created"`
                  	// A string of the desired Custom Data for the device.
                  	CustomData pulumi.StringPtrOutput `pulumi:"customData"`
                  	// The facility where the device is deployed.
                  	DeployedFacility pulumi.StringOutput `pulumi:"deployedFacility"`
                  	// ID of hardware reservation where this device was deployed. It is useful when using the `next-available` hardware reservation.
                  	DeployedHardwareReservationId pulumi.StringOutput `pulumi:"deployedHardwareReservationId"`
                  	// Description string for the device
                  	Description pulumi.StringPtrOutput `pulumi:"description"`
                  	// List of facility codes with deployment preferences. Equinix Metal API will go through the list and will deploy your device to first facility with free capacity. List items must be facility codes or `any` (a wildcard). To find the facility code, visit [Facilities API docs](https://metal.equinix.com/developers/api/facilities/), set your API auth token in the top of the page and see JSON from the API response.
                  	Facilities pulumi.StringArrayOutput `pulumi:"facilities"`
                  	// Delete device even if it has volumes attached. Only applies for destroy action.
                  	ForceDetachVolumes    pulumi.BoolPtrOutput   `pulumi:"forceDetachVolumes"`
                  	HardwareReservationId pulumi.StringPtrOutput `pulumi:"hardwareReservationId"`
                  	// The device name
                  	Hostname pulumi.StringOutput `pulumi:"hostname"`
                  	// A list of IP address types for the device (structure is documented below).
                  	IpAddresses DeviceIpAddressArrayOutput `pulumi:"ipAddresses"`
                  	// URL pointing to a hosted iPXE script. More
                  	// information is in the
                  	// [Custom iPXE](https://metal.equinix.com/developers/docs/servers/custom-ipxe/)
                  	// doc.
                  	IpxeScriptUrl pulumi.StringPtrOutput `pulumi:"ipxeScriptUrl"`
                  	// Whether the device is locked
                  	Locked pulumi.BoolOutput `pulumi:"locked"`
                  	// Deprecated: You should handle Network Type with the new metal_device_network_type resource.
                  	NetworkType pulumi.StringOutput `pulumi:"networkType"`
                  	// The device's private and public IP (v4 and v6) network details. When a device is run without any special network configuration, it will have 3 networks:
                  	// * Public IPv4 at `metal_device.name.network.0`
                  	// * IPv6 at `metal_device.name.network.1`
                  	// * Private IPv4 at `metal_device.name.network.2`
                  	//   Elastic addresses then stack by type - an assigned public IPv4 will go after the management public IPv4 (to index 1), and will then shift the indices of the IPv6 and private IPv4. Assigned private IPv4 will go after the management private IPv4 (to the end of the network list).
                  	//   The fields of the network attributes are:
                  	Networks DeviceNetworkArrayOutput `pulumi:"networks"`
                  	// The operating system slug. To find the slug, or visit [Operating Systems API docs](https://metal.equinix.com/developers/api/operatingsystems), set your API auth token in the top of the page and see JSON from the API response.
                  	OperatingSystem pulumi.StringOutput `pulumi:"operatingSystem"`
                  	// The device plan slug. To find the plan slug, visit [Device plans API docs](https://metal.equinix.com/developers/api/plans), set your auth token in the top of the page and see JSON from the API response.
                  	Plan pulumi.StringOutput `pulumi:"plan"`
                  	// Ports assigned to the device
                  	Ports DevicePortArrayOutput `pulumi:"ports"`
                  	// The ID of the project in which to create the device
                  	ProjectId pulumi.StringOutput `pulumi:"projectId"`
                  	// Array of IDs of the project SSH keys which should be added to the device. If you omit this, SSH keys of all the members of the parent project will be added to the device. If you specify this array, only the listed project SSH keys will be added. Project SSH keys can be created with the ProjectSshKey resource.
                  	ProjectSshKeyIds pulumi.StringArrayOutput `pulumi:"projectSshKeyIds"`
                  	// Root password to the server (disabled after 24 hours)
                  	RootPassword pulumi.StringOutput `pulumi:"rootPassword"`
                  	// List of IDs of SSH keys deployed in the device, can be both user and project SSH keys
                  	SshKeyIds pulumi.StringArrayOutput `pulumi:"sshKeyIds"`
                  	// The status of the device
                  	State pulumi.StringOutput `pulumi:"state"`
                  	// JSON for custom partitioning. Only usable on reserved hardware. More information in in the [Custom Partitioning and RAID](https://metal.equinix.com/developers/docs/servers/custom-partitioning-raid/) doc.
                  	// * Please note that the disks.partitions.size attribute must be a string, not an integer. It can be a number string, or size notation string, e.g. "4G" or "8M" (for gigabytes and megabytes).
                  	Storage pulumi.StringPtrOutput `pulumi:"storage"`
                  	// Tags attached to the device
                  	Tags pulumi.StringArrayOutput `pulumi:"tags"`
                  	// The timestamp for the last time the device was updated
                  	Updated pulumi.StringOutput `pulumi:"updated"`
                  	// A string of the desired User Data for the device.
                  	UserData pulumi.StringPtrOutput `pulumi:"userData"`
                  	// Only used for devices in reserved hardware. If set, the deletion of this device will block until the hardware reservation is marked provisionable (about 4 minutes in August 2019).
                  	WaitForReservationDeprovision pulumi.BoolPtrOutput `pulumi:"waitForReservationDeprovision"`
                  }

                  Provides an Equinix Metal device resource. This can be used to create, modify, and delete devices.

                  > **Note:** All arguments including the `rootPassword` and `userData` will be stored in

                  the raw state as plain-text.
                  

                  [Read more about sensitive data in state](https://www.terraform.io/docs/state/sensitive-data.html).

                  ## Example Usage

                  Create a device and add it to coolProject

                  “`go package main

                  import (

                  "github.com/pulumi/pulumi-equinix-metal/sdk/go/equinix-metal"
                  "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
                  

                  )

                  func main() {

                  pulumi.Run(func(ctx *pulumi.Context) error {
                  	_, err := equinix - metal.NewDevice(ctx, "web1", &equinix-metal.DeviceArgs{
                  		Hostname: pulumi.String("tf.coreos2"),
                  		Plan:     pulumi.String("t1.small.x86"),
                  		Facilities: pulumi.StringArray{
                  			pulumi.String("ewr1"),
                  		},
                  		OperatingSystem: pulumi.String("coreos_stable"),
                  		BillingCycle:    pulumi.String("hourly"),
                  		ProjectId:       pulumi.Any(local.Project_id),
                  	})
                  	if err != nil {
                  		return err
                  	}
                  	return nil
                  })
                  

                  } “`

                  Same as above, but boot via iPXE initially, using the Ignition Provider for provisioning

                  “`go package main

                  import (

                  "github.com/pulumi/pulumi-equinix-metal/sdk/go/equinix-metal"
                  "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
                  

                  )

                  func main() {

                  pulumi.Run(func(ctx *pulumi.Context) error {
                  	_, err := equinix - metal.NewDevice(ctx, "pxe1", &equinix-metal.DeviceArgs{
                  		Hostname: pulumi.String("tf.coreos2-pxe"),
                  		Plan:     pulumi.String("t1.small.x86"),
                  		Facilities: pulumi.StringArray{
                  			pulumi.String("ewr1"),
                  		},
                  		OperatingSystem: pulumi.String("custom_ipxe"),
                  		BillingCycle:    pulumi.String("hourly"),
                  		ProjectId:       pulumi.Any(local.Project_id),
                  		IpxeScriptUrl:   pulumi.String("https://rawgit.com/cloudnativelabs/pxe/master/metal/coreos-stable-metal.ipxe"),
                  		AlwaysPxe:       pulumi.Bool(false),
                  		UserData:        pulumi.Any(data.Ignition_config.Example.Rendered),
                  	})
                  	if err != nil {
                  		return err
                  	}
                  	return nil
                  })
                  

                  } “`

                  Create a device without a public IP address, with only a /30 private IPv4 subnet (4 IP addresses)

                  “`go package main

                  import (

                  "github.com/pulumi/pulumi-equinix-metal/sdk/go/equinix-metal"
                  "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
                  

                  )

                  func main() {

                  pulumi.Run(func(ctx *pulumi.Context) error {
                  	_, err := equinix - metal.NewDevice(ctx, "web1", &equinix-metal.DeviceArgs{
                  		Hostname: pulumi.String("tf.coreos2"),
                  		Plan:     pulumi.String("t1.small.x86"),
                  		Facilities: pulumi.StringArray{
                  			pulumi.String("ewr1"),
                  		},
                  		OperatingSystem: pulumi.String("coreos_stable"),
                  		BillingCycle:    pulumi.String("hourly"),
                  		ProjectId:       pulumi.Any(local.Project_id),
                  		IpAddresses: equinix - metal.DeviceIpAddressArray{
                  			&equinix - metal.DeviceIpAddressArgs{
                  				Type: pulumi.String("private_ipv4"),
                  				Cidr: pulumi.Int(30),
                  			},
                  		},
                  	})
                  	if err != nil {
                  		return err
                  	}
                  	return nil
                  })
                  

                  } “`

                  Deploy device on next-available reserved hardware and do custom partitioning.

                  “`go package main

                  import (

                  "fmt"
                  
                  "github.com/pulumi/pulumi-equinix-metal/sdk/go/equinix-metal"
                  "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
                  

                  )

                  func main() {

                  pulumi.Run(func(ctx *pulumi.Context) error {
                  	_, err := equinix - metal.NewDevice(ctx, "web1", &equinix-metal.DeviceArgs{
                  		Hostname: pulumi.String("tftest"),
                  		Plan:     pulumi.String("t1.small.x86"),
                  		Facilities: pulumi.StringArray{
                  			pulumi.String("sjc1"),
                  		},
                  		OperatingSystem:       pulumi.String("ubuntu_16_04"),
                  		BillingCycle:          pulumi.String("hourly"),
                  		ProjectId:             pulumi.Any(local.Project_id),
                  		HardwareReservationId: pulumi.String("next-available"),
                  		Storage:               pulumi.String(fmt.Sprintf("%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v%v", "{\n", "  \"disks\": [\n", "    {\n", "      \"device\": \"/dev/sda\",\n", "      \"wipeTable\": true,\n", "      \"partitions\": [\n", "        {\n", "          \"label\": \"BIOS\",\n", "          \"number\": 1,\n", "          \"size\": \"4096\"\n", "        },\n", "        {\n", "          \"label\": \"SWAP\",\n", "          \"number\": 2,\n", "          \"size\": \"3993600\"\n", "        },\n", "        {\n", "          \"label\": \"ROOT\",\n", "          \"number\": 3,\n", "          \"size\": \"0\"\n", "        }\n", "      ]\n", "    }\n", "  ],\n", "  \"filesystems\": [\n", "    {\n", "      \"mount\": {\n", "        \"device\": \"/dev/sda3\",\n", "        \"format\": \"ext4\",\n", "        \"point\": \"/\",\n", "        \"create\": {\n", "          \"options\": [\n", "            \"-L\",\n", "            \"ROOT\"\n", "          ]\n", "        }\n", "      }\n", "    },\n", "    {\n", "      \"mount\": {\n", "        \"device\": \"/dev/sda2\",\n", "        \"format\": \"swap\",\n", "        \"point\": \"none\",\n", "        \"create\": {\n", "          \"options\": [\n", "            \"-L\",\n", "            \"SWAP\"\n", "          ]\n", "        }\n", "      }\n", "    }\n", "  ]\n", "}\n")),
                  	})
                  	if err != nil {
                  		return err
                  	}
                  	return nil
                  })
                  

                  } “`

                  func GetDevice

                  func GetDevice(ctx *pulumi.Context,
                  	name string, id pulumi.IDInput, state *DeviceState, opts ...pulumi.ResourceOption) (*Device, error)

                    GetDevice gets an existing Device resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

                    func NewDevice

                    func NewDevice(ctx *pulumi.Context,
                    	name string, args *DeviceArgs, opts ...pulumi.ResourceOption) (*Device, error)

                      NewDevice registers a new resource with the given unique name, arguments, and options.

                      func (*Device) ElementType

                      func (*Device) ElementType() reflect.Type

                      func (*Device) ToDeviceOutput

                      func (i *Device) ToDeviceOutput() DeviceOutput

                      func (*Device) ToDeviceOutputWithContext

                      func (i *Device) ToDeviceOutputWithContext(ctx context.Context) DeviceOutput

                      func (*Device) ToDevicePtrOutput

                      func (i *Device) ToDevicePtrOutput() DevicePtrOutput

                      func (*Device) ToDevicePtrOutputWithContext

                      func (i *Device) ToDevicePtrOutputWithContext(ctx context.Context) DevicePtrOutput

                      type DeviceArgs

                      type DeviceArgs struct {
                      	// If true, a device with OS `customIpxe` will
                      	// continue to boot via iPXE on reboots.
                      	AlwaysPxe pulumi.BoolPtrInput
                      	// monthly or hourly
                      	BillingCycle pulumi.StringInput
                      	// A string of the desired Custom Data for the device.
                      	CustomData pulumi.StringPtrInput
                      	// Description string for the device
                      	Description pulumi.StringPtrInput
                      	// List of facility codes with deployment preferences. Equinix Metal API will go through the list and will deploy your device to first facility with free capacity. List items must be facility codes or `any` (a wildcard). To find the facility code, visit [Facilities API docs](https://metal.equinix.com/developers/api/facilities/), set your API auth token in the top of the page and see JSON from the API response.
                      	Facilities pulumi.StringArrayInput
                      	// Delete device even if it has volumes attached. Only applies for destroy action.
                      	ForceDetachVolumes    pulumi.BoolPtrInput
                      	HardwareReservationId pulumi.StringPtrInput
                      	// The device name
                      	Hostname pulumi.StringInput
                      	// A list of IP address types for the device (structure is documented below).
                      	IpAddresses DeviceIpAddressArrayInput
                      	// URL pointing to a hosted iPXE script. More
                      	// information is in the
                      	// [Custom iPXE](https://metal.equinix.com/developers/docs/servers/custom-ipxe/)
                      	// doc.
                      	IpxeScriptUrl pulumi.StringPtrInput
                      	// The operating system slug. To find the slug, or visit [Operating Systems API docs](https://metal.equinix.com/developers/api/operatingsystems), set your API auth token in the top of the page and see JSON from the API response.
                      	OperatingSystem pulumi.StringInput
                      	// The device plan slug. To find the plan slug, visit [Device plans API docs](https://metal.equinix.com/developers/api/plans), set your auth token in the top of the page and see JSON from the API response.
                      	Plan pulumi.StringInput
                      	// The ID of the project in which to create the device
                      	ProjectId pulumi.StringInput
                      	// Array of IDs of the project SSH keys which should be added to the device. If you omit this, SSH keys of all the members of the parent project will be added to the device. If you specify this array, only the listed project SSH keys will be added. Project SSH keys can be created with the ProjectSshKey resource.
                      	ProjectSshKeyIds pulumi.StringArrayInput
                      	// JSON for custom partitioning. Only usable on reserved hardware. More information in in the [Custom Partitioning and RAID](https://metal.equinix.com/developers/docs/servers/custom-partitioning-raid/) doc.
                      	// * Please note that the disks.partitions.size attribute must be a string, not an integer. It can be a number string, or size notation string, e.g. "4G" or "8M" (for gigabytes and megabytes).
                      	Storage pulumi.StringPtrInput
                      	// Tags attached to the device
                      	Tags pulumi.StringArrayInput
                      	// A string of the desired User Data for the device.
                      	UserData pulumi.StringPtrInput
                      	// Only used for devices in reserved hardware. If set, the deletion of this device will block until the hardware reservation is marked provisionable (about 4 minutes in August 2019).
                      	WaitForReservationDeprovision pulumi.BoolPtrInput
                      }

                        The set of arguments for constructing a Device resource.

                        func (DeviceArgs) ElementType

                        func (DeviceArgs) ElementType() reflect.Type

                        type DeviceArray

                        type DeviceArray []DeviceInput

                        func (DeviceArray) ElementType

                        func (DeviceArray) ElementType() reflect.Type

                        func (DeviceArray) ToDeviceArrayOutput

                        func (i DeviceArray) ToDeviceArrayOutput() DeviceArrayOutput

                        func (DeviceArray) ToDeviceArrayOutputWithContext

                        func (i DeviceArray) ToDeviceArrayOutputWithContext(ctx context.Context) DeviceArrayOutput

                        type DeviceArrayInput

                        type DeviceArrayInput interface {
                        	pulumi.Input
                        
                        	ToDeviceArrayOutput() DeviceArrayOutput
                        	ToDeviceArrayOutputWithContext(context.Context) DeviceArrayOutput
                        }

                          DeviceArrayInput is an input type that accepts DeviceArray and DeviceArrayOutput values. You can construct a concrete instance of `DeviceArrayInput` via:

                          DeviceArray{ DeviceArgs{...} }
                          

                          type DeviceArrayOutput

                          type DeviceArrayOutput struct{ *pulumi.OutputState }

                          func (DeviceArrayOutput) ElementType

                          func (DeviceArrayOutput) ElementType() reflect.Type

                          func (DeviceArrayOutput) Index

                          func (DeviceArrayOutput) ToDeviceArrayOutput

                          func (o DeviceArrayOutput) ToDeviceArrayOutput() DeviceArrayOutput

                          func (DeviceArrayOutput) ToDeviceArrayOutputWithContext

                          func (o DeviceArrayOutput) ToDeviceArrayOutputWithContext(ctx context.Context) DeviceArrayOutput

                          type DeviceInput

                          type DeviceInput interface {
                          	pulumi.Input
                          
                          	ToDeviceOutput() DeviceOutput
                          	ToDeviceOutputWithContext(ctx context.Context) DeviceOutput
                          }

                          type DeviceIpAddress

                          type DeviceIpAddress struct {
                          	// CIDR suffix for IP address block to be assigned, i.e. amount of addresses.
                          	Cidr *int `pulumi:"cidr"`
                          	// String of UUID of IP block reservations from which the public IPv4 address should be taken.
                          	ReservationIds []string `pulumi:"reservationIds"`
                          	// One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]
                          	Type string `pulumi:"type"`
                          }

                          type DeviceIpAddressArgs

                          type DeviceIpAddressArgs struct {
                          	// CIDR suffix for IP address block to be assigned, i.e. amount of addresses.
                          	Cidr pulumi.IntPtrInput `pulumi:"cidr"`
                          	// String of UUID of IP block reservations from which the public IPv4 address should be taken.
                          	ReservationIds pulumi.StringArrayInput `pulumi:"reservationIds"`
                          	// One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]
                          	Type pulumi.StringInput `pulumi:"type"`
                          }

                          func (DeviceIpAddressArgs) ElementType

                          func (DeviceIpAddressArgs) ElementType() reflect.Type

                          func (DeviceIpAddressArgs) ToDeviceIpAddressOutput

                          func (i DeviceIpAddressArgs) ToDeviceIpAddressOutput() DeviceIpAddressOutput

                          func (DeviceIpAddressArgs) ToDeviceIpAddressOutputWithContext

                          func (i DeviceIpAddressArgs) ToDeviceIpAddressOutputWithContext(ctx context.Context) DeviceIpAddressOutput

                          type DeviceIpAddressArray

                          type DeviceIpAddressArray []DeviceIpAddressInput

                          func (DeviceIpAddressArray) ElementType

                          func (DeviceIpAddressArray) ElementType() reflect.Type

                          func (DeviceIpAddressArray) ToDeviceIpAddressArrayOutput

                          func (i DeviceIpAddressArray) ToDeviceIpAddressArrayOutput() DeviceIpAddressArrayOutput

                          func (DeviceIpAddressArray) ToDeviceIpAddressArrayOutputWithContext

                          func (i DeviceIpAddressArray) ToDeviceIpAddressArrayOutputWithContext(ctx context.Context) DeviceIpAddressArrayOutput

                          type DeviceIpAddressArrayInput

                          type DeviceIpAddressArrayInput interface {
                          	pulumi.Input
                          
                          	ToDeviceIpAddressArrayOutput() DeviceIpAddressArrayOutput
                          	ToDeviceIpAddressArrayOutputWithContext(context.Context) DeviceIpAddressArrayOutput
                          }

                            DeviceIpAddressArrayInput is an input type that accepts DeviceIpAddressArray and DeviceIpAddressArrayOutput values. You can construct a concrete instance of `DeviceIpAddressArrayInput` via:

                            DeviceIpAddressArray{ DeviceIpAddressArgs{...} }
                            

                            type DeviceIpAddressArrayOutput

                            type DeviceIpAddressArrayOutput struct{ *pulumi.OutputState }

                            func (DeviceIpAddressArrayOutput) ElementType

                            func (DeviceIpAddressArrayOutput) ElementType() reflect.Type

                            func (DeviceIpAddressArrayOutput) Index

                            func (DeviceIpAddressArrayOutput) ToDeviceIpAddressArrayOutput

                            func (o DeviceIpAddressArrayOutput) ToDeviceIpAddressArrayOutput() DeviceIpAddressArrayOutput

                            func (DeviceIpAddressArrayOutput) ToDeviceIpAddressArrayOutputWithContext

                            func (o DeviceIpAddressArrayOutput) ToDeviceIpAddressArrayOutputWithContext(ctx context.Context) DeviceIpAddressArrayOutput

                            type DeviceIpAddressInput

                            type DeviceIpAddressInput interface {
                            	pulumi.Input
                            
                            	ToDeviceIpAddressOutput() DeviceIpAddressOutput
                            	ToDeviceIpAddressOutputWithContext(context.Context) DeviceIpAddressOutput
                            }

                              DeviceIpAddressInput is an input type that accepts DeviceIpAddressArgs and DeviceIpAddressOutput values. You can construct a concrete instance of `DeviceIpAddressInput` via:

                              DeviceIpAddressArgs{...}
                              

                              type DeviceIpAddressOutput

                              type DeviceIpAddressOutput struct{ *pulumi.OutputState }

                              func (DeviceIpAddressOutput) Cidr

                                CIDR suffix for IP address block to be assigned, i.e. amount of addresses.

                                func (DeviceIpAddressOutput) ElementType

                                func (DeviceIpAddressOutput) ElementType() reflect.Type

                                func (DeviceIpAddressOutput) ReservationIds

                                func (o DeviceIpAddressOutput) ReservationIds() pulumi.StringArrayOutput

                                  String of UUID of IP block reservations from which the public IPv4 address should be taken.

                                  func (DeviceIpAddressOutput) ToDeviceIpAddressOutput

                                  func (o DeviceIpAddressOutput) ToDeviceIpAddressOutput() DeviceIpAddressOutput

                                  func (DeviceIpAddressOutput) ToDeviceIpAddressOutputWithContext

                                  func (o DeviceIpAddressOutput) ToDeviceIpAddressOutputWithContext(ctx context.Context) DeviceIpAddressOutput

                                  func (DeviceIpAddressOutput) Type

                                    One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]

                                    type DeviceMap

                                    type DeviceMap map[string]DeviceInput

                                    func (DeviceMap) ElementType

                                    func (DeviceMap) ElementType() reflect.Type

                                    func (DeviceMap) ToDeviceMapOutput

                                    func (i DeviceMap) ToDeviceMapOutput() DeviceMapOutput

                                    func (DeviceMap) ToDeviceMapOutputWithContext

                                    func (i DeviceMap) ToDeviceMapOutputWithContext(ctx context.Context) DeviceMapOutput

                                    type DeviceMapInput

                                    type DeviceMapInput interface {
                                    	pulumi.Input
                                    
                                    	ToDeviceMapOutput() DeviceMapOutput
                                    	ToDeviceMapOutputWithContext(context.Context) DeviceMapOutput
                                    }

                                      DeviceMapInput is an input type that accepts DeviceMap and DeviceMapOutput values. You can construct a concrete instance of `DeviceMapInput` via:

                                      DeviceMap{ "key": DeviceArgs{...} }
                                      

                                      type DeviceMapOutput

                                      type DeviceMapOutput struct{ *pulumi.OutputState }

                                      func (DeviceMapOutput) ElementType

                                      func (DeviceMapOutput) ElementType() reflect.Type

                                      func (DeviceMapOutput) MapIndex

                                      func (DeviceMapOutput) ToDeviceMapOutput

                                      func (o DeviceMapOutput) ToDeviceMapOutput() DeviceMapOutput

                                      func (DeviceMapOutput) ToDeviceMapOutputWithContext

                                      func (o DeviceMapOutput) ToDeviceMapOutputWithContext(ctx context.Context) DeviceMapOutput

                                      type DeviceNetwork

                                      type DeviceNetwork struct {
                                      	// IPv4 or IPv6 address string
                                      	Address *string `pulumi:"address"`
                                      	// CIDR suffix for IP address block to be assigned, i.e. amount of addresses.
                                      	Cidr *int `pulumi:"cidr"`
                                      	// IP version - "4" or "6"
                                      	// * `networkType` Network type of a device, used in [Layer 2 networking](https://metal.equinix.com/developers/docs/networking/layer2/). Will be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.
                                      	Family *int `pulumi:"family"`
                                      	// address of router
                                      	Gateway *string `pulumi:"gateway"`
                                      	// whether the address is routable from the Internet
                                      	Public *bool `pulumi:"public"`
                                      }

                                      type DeviceNetworkArgs

                                      type DeviceNetworkArgs struct {
                                      	// IPv4 or IPv6 address string
                                      	Address pulumi.StringPtrInput `pulumi:"address"`
                                      	// CIDR suffix for IP address block to be assigned, i.e. amount of addresses.
                                      	Cidr pulumi.IntPtrInput `pulumi:"cidr"`
                                      	// IP version - "4" or "6"
                                      	// * `networkType` Network type of a device, used in [Layer 2 networking](https://metal.equinix.com/developers/docs/networking/layer2/). Will be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.
                                      	Family pulumi.IntPtrInput `pulumi:"family"`
                                      	// address of router
                                      	Gateway pulumi.StringPtrInput `pulumi:"gateway"`
                                      	// whether the address is routable from the Internet
                                      	Public pulumi.BoolPtrInput `pulumi:"public"`
                                      }

                                      func (DeviceNetworkArgs) ElementType

                                      func (DeviceNetworkArgs) ElementType() reflect.Type

                                      func (DeviceNetworkArgs) ToDeviceNetworkOutput

                                      func (i DeviceNetworkArgs) ToDeviceNetworkOutput() DeviceNetworkOutput

                                      func (DeviceNetworkArgs) ToDeviceNetworkOutputWithContext

                                      func (i DeviceNetworkArgs) ToDeviceNetworkOutputWithContext(ctx context.Context) DeviceNetworkOutput

                                      type DeviceNetworkArray

                                      type DeviceNetworkArray []DeviceNetworkInput

                                      func (DeviceNetworkArray) ElementType

                                      func (DeviceNetworkArray) ElementType() reflect.Type

                                      func (DeviceNetworkArray) ToDeviceNetworkArrayOutput

                                      func (i DeviceNetworkArray) ToDeviceNetworkArrayOutput() DeviceNetworkArrayOutput

                                      func (DeviceNetworkArray) ToDeviceNetworkArrayOutputWithContext

                                      func (i DeviceNetworkArray) ToDeviceNetworkArrayOutputWithContext(ctx context.Context) DeviceNetworkArrayOutput

                                      type DeviceNetworkArrayInput

                                      type DeviceNetworkArrayInput interface {
                                      	pulumi.Input
                                      
                                      	ToDeviceNetworkArrayOutput() DeviceNetworkArrayOutput
                                      	ToDeviceNetworkArrayOutputWithContext(context.Context) DeviceNetworkArrayOutput
                                      }

                                        DeviceNetworkArrayInput is an input type that accepts DeviceNetworkArray and DeviceNetworkArrayOutput values. You can construct a concrete instance of `DeviceNetworkArrayInput` via:

                                        DeviceNetworkArray{ DeviceNetworkArgs{...} }
                                        

                                        type DeviceNetworkArrayOutput

                                        type DeviceNetworkArrayOutput struct{ *pulumi.OutputState }

                                        func (DeviceNetworkArrayOutput) ElementType

                                        func (DeviceNetworkArrayOutput) ElementType() reflect.Type

                                        func (DeviceNetworkArrayOutput) Index

                                        func (DeviceNetworkArrayOutput) ToDeviceNetworkArrayOutput

                                        func (o DeviceNetworkArrayOutput) ToDeviceNetworkArrayOutput() DeviceNetworkArrayOutput

                                        func (DeviceNetworkArrayOutput) ToDeviceNetworkArrayOutputWithContext

                                        func (o DeviceNetworkArrayOutput) ToDeviceNetworkArrayOutputWithContext(ctx context.Context) DeviceNetworkArrayOutput

                                        type DeviceNetworkInput

                                        type DeviceNetworkInput interface {
                                        	pulumi.Input
                                        
                                        	ToDeviceNetworkOutput() DeviceNetworkOutput
                                        	ToDeviceNetworkOutputWithContext(context.Context) DeviceNetworkOutput
                                        }

                                          DeviceNetworkInput is an input type that accepts DeviceNetworkArgs and DeviceNetworkOutput values. You can construct a concrete instance of `DeviceNetworkInput` via:

                                          DeviceNetworkArgs{...}
                                          

                                          type DeviceNetworkOutput

                                          type DeviceNetworkOutput struct{ *pulumi.OutputState }

                                          func (DeviceNetworkOutput) Address

                                            IPv4 or IPv6 address string

                                            func (DeviceNetworkOutput) Cidr

                                              CIDR suffix for IP address block to be assigned, i.e. amount of addresses.

                                              func (DeviceNetworkOutput) ElementType

                                              func (DeviceNetworkOutput) ElementType() reflect.Type

                                              func (DeviceNetworkOutput) Family

                                                IP version - "4" or "6" * `networkType` Network type of a device, used in [Layer 2 networking](https://metal.equinix.com/developers/docs/networking/layer2/). Will be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.

                                                func (DeviceNetworkOutput) Gateway

                                                  address of router

                                                  func (DeviceNetworkOutput) Public

                                                    whether the address is routable from the Internet

                                                    func (DeviceNetworkOutput) ToDeviceNetworkOutput

                                                    func (o DeviceNetworkOutput) ToDeviceNetworkOutput() DeviceNetworkOutput

                                                    func (DeviceNetworkOutput) ToDeviceNetworkOutputWithContext

                                                    func (o DeviceNetworkOutput) ToDeviceNetworkOutputWithContext(ctx context.Context) DeviceNetworkOutput

                                                    type DeviceNetworkType

                                                    type DeviceNetworkType struct {
                                                    	pulumi.CustomResourceState
                                                    
                                                    	// The ID of the device on which the network type should be set.
                                                    	DeviceId pulumi.StringOutput `pulumi:"deviceId"`
                                                    	// Network type to set. Must be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.
                                                    	Type pulumi.StringOutput `pulumi:"type"`
                                                    }

                                                    ## Import

                                                    This resource can also be imported using existing device ID

                                                    “`sh

                                                    $ pulumi import equinix-metal:index/deviceNetworkType:DeviceNetworkType metal_device_network_type {existing device_id}
                                                    

                                                    “`

                                                    func GetDeviceNetworkType

                                                    func GetDeviceNetworkType(ctx *pulumi.Context,
                                                    	name string, id pulumi.IDInput, state *DeviceNetworkTypeState, opts ...pulumi.ResourceOption) (*DeviceNetworkType, error)

                                                      GetDeviceNetworkType gets an existing DeviceNetworkType resource's state with the given name, ID, and optional state properties that are used to uniquely qualify the lookup (nil if not required).

                                                      func NewDeviceNetworkType

                                                      func NewDeviceNetworkType(ctx *pulumi.Context,
                                                      	name string, args *DeviceNetworkTypeArgs, opts ...pulumi.ResourceOption) (*DeviceNetworkType, error)

                                                        NewDeviceNetworkType registers a new resource with the given unique name, arguments, and options.

                                                        func (*DeviceNetworkType) ElementType

                                                        func (*DeviceNetworkType) ElementType() reflect.Type

                                                        func (*DeviceNetworkType) ToDeviceNetworkTypeOutput

                                                        func (i *DeviceNetworkType) ToDeviceNetworkTypeOutput() DeviceNetworkTypeOutput

                                                        func (*DeviceNetworkType) ToDeviceNetworkTypeOutputWithContext

                                                        func (i *DeviceNetworkType) ToDeviceNetworkTypeOutputWithContext(ctx context.Context) DeviceNetworkTypeOutput

                                                        func (*DeviceNetworkType) ToDeviceNetworkTypePtrOutput

                                                        func (i *DeviceNetworkType) ToDeviceNetworkTypePtrOutput() DeviceNetworkTypePtrOutput

                                                        func (*DeviceNetworkType) ToDeviceNetworkTypePtrOutputWithContext

                                                        func (i *DeviceNetworkType) ToDeviceNetworkTypePtrOutputWithContext(ctx context.Context) DeviceNetworkTypePtrOutput

                                                        type DeviceNetworkTypeArgs

                                                        type DeviceNetworkTypeArgs struct {
                                                        	// The ID of the device on which the network type should be set.
                                                        	DeviceId pulumi.StringInput
                                                        	// Network type to set. Must be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.
                                                        	Type pulumi.StringInput
                                                        }

                                                          The set of arguments for constructing a DeviceNetworkType resource.

                                                          func (DeviceNetworkTypeArgs) ElementType

                                                          func (DeviceNetworkTypeArgs) ElementType() reflect.Type

                                                          type DeviceNetworkTypeArray

                                                          type DeviceNetworkTypeArray []DeviceNetworkTypeInput

                                                          func (DeviceNetworkTypeArray) ElementType

                                                          func (DeviceNetworkTypeArray) ElementType() reflect.Type

                                                          func (DeviceNetworkTypeArray) ToDeviceNetworkTypeArrayOutput

                                                          func (i DeviceNetworkTypeArray) ToDeviceNetworkTypeArrayOutput() DeviceNetworkTypeArrayOutput

                                                          func (DeviceNetworkTypeArray) ToDeviceNetworkTypeArrayOutputWithContext

                                                          func (i DeviceNetworkTypeArray) ToDeviceNetworkTypeArrayOutputWithContext(ctx context.Context) DeviceNetworkTypeArrayOutput

                                                          type DeviceNetworkTypeArrayInput

                                                          type DeviceNetworkTypeArrayInput interface {
                                                          	pulumi.Input
                                                          
                                                          	ToDeviceNetworkTypeArrayOutput() DeviceNetworkTypeArrayOutput
                                                          	ToDeviceNetworkTypeArrayOutputWithContext(context.Context) DeviceNetworkTypeArrayOutput
                                                          }

                                                            DeviceNetworkTypeArrayInput is an input type that accepts DeviceNetworkTypeArray and DeviceNetworkTypeArrayOutput values. You can construct a concrete instance of `DeviceNetworkTypeArrayInput` via:

                                                            DeviceNetworkTypeArray{ DeviceNetworkTypeArgs{...} }
                                                            

                                                            type DeviceNetworkTypeArrayOutput

                                                            type DeviceNetworkTypeArrayOutput struct{ *pulumi.OutputState }

                                                            func (DeviceNetworkTypeArrayOutput) ElementType

                                                            func (DeviceNetworkTypeArrayOutput) Index

                                                            func (DeviceNetworkTypeArrayOutput) ToDeviceNetworkTypeArrayOutput

                                                            func (o DeviceNetworkTypeArrayOutput) ToDeviceNetworkTypeArrayOutput() DeviceNetworkTypeArrayOutput

                                                            func (DeviceNetworkTypeArrayOutput) ToDeviceNetworkTypeArrayOutputWithContext

                                                            func (o DeviceNetworkTypeArrayOutput) ToDeviceNetworkTypeArrayOutputWithContext(ctx context.Context) DeviceNetworkTypeArrayOutput

                                                            type DeviceNetworkTypeInput

                                                            type DeviceNetworkTypeInput interface {
                                                            	pulumi.Input
                                                            
                                                            	ToDeviceNetworkTypeOutput() DeviceNetworkTypeOutput
                                                            	ToDeviceNetworkTypeOutputWithContext(ctx context.Context) DeviceNetworkTypeOutput
                                                            }

                                                            type DeviceNetworkTypeMap

                                                            type DeviceNetworkTypeMap map[string]DeviceNetworkTypeInput

                                                            func (DeviceNetworkTypeMap) ElementType

                                                            func (DeviceNetworkTypeMap) ElementType() reflect.Type

                                                            func (DeviceNetworkTypeMap) ToDeviceNetworkTypeMapOutput

                                                            func (i DeviceNetworkTypeMap) ToDeviceNetworkTypeMapOutput() DeviceNetworkTypeMapOutput

                                                            func (DeviceNetworkTypeMap) ToDeviceNetworkTypeMapOutputWithContext

                                                            func (i DeviceNetworkTypeMap) ToDeviceNetworkTypeMapOutputWithContext(ctx context.Context) DeviceNetworkTypeMapOutput

                                                            type DeviceNetworkTypeMapInput

                                                            type DeviceNetworkTypeMapInput interface {
                                                            	pulumi.Input
                                                            
                                                            	ToDeviceNetworkTypeMapOutput() DeviceNetworkTypeMapOutput
                                                            	ToDeviceNetworkTypeMapOutputWithContext(context.Context) DeviceNetworkTypeMapOutput
                                                            }

                                                              DeviceNetworkTypeMapInput is an input type that accepts DeviceNetworkTypeMap and DeviceNetworkTypeMapOutput values. You can construct a concrete instance of `DeviceNetworkTypeMapInput` via:

                                                              DeviceNetworkTypeMap{ "key": DeviceNetworkTypeArgs{...} }
                                                              

                                                              type DeviceNetworkTypeMapOutput

                                                              type DeviceNetworkTypeMapOutput struct{ *pulumi.OutputState }

                                                              func (DeviceNetworkTypeMapOutput) ElementType

                                                              func (DeviceNetworkTypeMapOutput) ElementType() reflect.Type

                                                              func (DeviceNetworkTypeMapOutput) MapIndex

                                                              func (DeviceNetworkTypeMapOutput) ToDeviceNetworkTypeMapOutput

                                                              func (o DeviceNetworkTypeMapOutput) ToDeviceNetworkTypeMapOutput() DeviceNetworkTypeMapOutput

                                                              func (DeviceNetworkTypeMapOutput) ToDeviceNetworkTypeMapOutputWithContext

                                                              func (o DeviceNetworkTypeMapOutput) ToDeviceNetworkTypeMapOutputWithContext(ctx context.Context) DeviceNetworkTypeMapOutput

                                                              type DeviceNetworkTypeOutput

                                                              type DeviceNetworkTypeOutput struct {
                                                              	*pulumi.OutputState
                                                              }

                                                              func (DeviceNetworkTypeOutput) ElementType

                                                              func (DeviceNetworkTypeOutput) ElementType() reflect.Type

                                                              func (DeviceNetworkTypeOutput) ToDeviceNetworkTypeOutput

                                                              func (o DeviceNetworkTypeOutput) ToDeviceNetworkTypeOutput() DeviceNetworkTypeOutput

                                                              func (DeviceNetworkTypeOutput) ToDeviceNetworkTypeOutputWithContext

                                                              func (o DeviceNetworkTypeOutput) ToDeviceNetworkTypeOutputWithContext(ctx context.Context) DeviceNetworkTypeOutput

                                                              func (DeviceNetworkTypeOutput) ToDeviceNetworkTypePtrOutput

                                                              func (o DeviceNetworkTypeOutput) ToDeviceNetworkTypePtrOutput() DeviceNetworkTypePtrOutput

                                                              func (DeviceNetworkTypeOutput) ToDeviceNetworkTypePtrOutputWithContext

                                                              func (o DeviceNetworkTypeOutput) ToDeviceNetworkTypePtrOutputWithContext(ctx context.Context) DeviceNetworkTypePtrOutput

                                                              type DeviceNetworkTypePtrInput

                                                              type DeviceNetworkTypePtrInput interface {
                                                              	pulumi.Input
                                                              
                                                              	ToDeviceNetworkTypePtrOutput() DeviceNetworkTypePtrOutput
                                                              	ToDeviceNetworkTypePtrOutputWithContext(ctx context.Context) DeviceNetworkTypePtrOutput
                                                              }

                                                              type DeviceNetworkTypePtrOutput

                                                              type DeviceNetworkTypePtrOutput struct {
                                                              	*pulumi.OutputState
                                                              }

                                                              func (DeviceNetworkTypePtrOutput) ElementType

                                                              func (DeviceNetworkTypePtrOutput) ElementType() reflect.Type

                                                              func (DeviceNetworkTypePtrOutput) ToDeviceNetworkTypePtrOutput

                                                              func (o DeviceNetworkTypePtrOutput) ToDeviceNetworkTypePtrOutput() DeviceNetworkTypePtrOutput

                                                              func (DeviceNetworkTypePtrOutput) ToDeviceNetworkTypePtrOutputWithContext

                                                              func (o DeviceNetworkTypePtrOutput) ToDeviceNetworkTypePtrOutputWithContext(ctx context.Context) DeviceNetworkTypePtrOutput

                                                              type DeviceNetworkTypeState

                                                              type DeviceNetworkTypeState struct {
                                                              	// The ID of the device on which the network type should be set.
                                                              	DeviceId pulumi.StringPtrInput
                                                              	// Network type to set. Must be one of `layer3`, `hybrid`, `layer2-individual` and `layer2-bonded`.
                                                              	Type pulumi.StringPtrInput
                                                              }

                                                              func (DeviceNetworkTypeState) ElementType

                                                              func (DeviceNetworkTypeState) ElementType() reflect.Type

                                                              type DeviceOutput

                                                              type DeviceOutput struct {
                                                              	*pulumi.OutputState
                                                              }

                                                              func (DeviceOutput) ElementType

                                                              func (DeviceOutput) ElementType() reflect.Type

                                                              func (DeviceOutput) ToDeviceOutput

                                                              func (o DeviceOutput) ToDeviceOutput() DeviceOutput

                                                              func (DeviceOutput) ToDeviceOutputWithContext

                                                              func (o DeviceOutput) ToDeviceOutputWithContext(ctx context.Context) DeviceOutput

                                                              func (DeviceOutput) ToDevicePtrOutput

                                                              func (o DeviceOutput) ToDevicePtrOutput() DevicePtrOutput

                                                              func (DeviceOutput) ToDevicePtrOutputWithContext

                                                              func (o DeviceOutput) ToDevicePtrOutputWithContext(ctx context.Context) DevicePtrOutput

                                                              type DevicePort

                                                              type DevicePort struct {
                                                              	// Whether this port is part of a bond in bonded network setup
                                                              	// * `projectId`- The ID of the project the device belongs to
                                                              	Bonded *bool `pulumi:"bonded"`
                                                              	// ID of the port
                                                              	Id *string `pulumi:"id"`
                                                              	// MAC address assigned to the port
                                                              	Mac *string `pulumi:"mac"`
                                                              	// Name of the port (e.g. `eth0`, or `bond0`)
                                                              	Name *string `pulumi:"name"`
                                                              	// One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]
                                                              	Type *string `pulumi:"type"`
                                                              }

                                                              type DevicePortArgs

                                                              type DevicePortArgs struct {
                                                              	// Whether this port is part of a bond in bonded network setup
                                                              	// * `projectId`- The ID of the project the device belongs to
                                                              	Bonded pulumi.BoolPtrInput `pulumi:"bonded"`
                                                              	// ID of the port
                                                              	Id pulumi.StringPtrInput `pulumi:"id"`
                                                              	// MAC address assigned to the port
                                                              	Mac pulumi.StringPtrInput `pulumi:"mac"`
                                                              	// Name of the port (e.g. `eth0`, or `bond0`)
                                                              	Name pulumi.StringPtrInput `pulumi:"name"`
                                                              	// One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]
                                                              	Type pulumi.StringPtrInput `pulumi:"type"`
                                                              }

                                                              func (DevicePortArgs) ElementType

                                                              func (DevicePortArgs) ElementType() reflect.Type

                                                              func (DevicePortArgs) ToDevicePortOutput

                                                              func (i DevicePortArgs) ToDevicePortOutput() DevicePortOutput

                                                              func (DevicePortArgs) ToDevicePortOutputWithContext

                                                              func (i DevicePortArgs) ToDevicePortOutputWithContext(ctx context.Context) DevicePortOutput

                                                              type DevicePortArray

                                                              type DevicePortArray []DevicePortInput

                                                              func (DevicePortArray) ElementType

                                                              func (DevicePortArray) ElementType() reflect.Type

                                                              func (DevicePortArray) ToDevicePortArrayOutput

                                                              func (i DevicePortArray) ToDevicePortArrayOutput() DevicePortArrayOutput

                                                              func (DevicePortArray) ToDevicePortArrayOutputWithContext

                                                              func (i DevicePortArray) ToDevicePortArrayOutputWithContext(ctx context.Context) DevicePortArrayOutput

                                                              type DevicePortArrayInput

                                                              type DevicePortArrayInput interface {
                                                              	pulumi.Input
                                                              
                                                              	ToDevicePortArrayOutput() DevicePortArrayOutput
                                                              	ToDevicePortArrayOutputWithContext(context.Context) DevicePortArrayOutput
                                                              }

                                                                DevicePortArrayInput is an input type that accepts DevicePortArray and DevicePortArrayOutput values. You can construct a concrete instance of `DevicePortArrayInput` via:

                                                                DevicePortArray{ DevicePortArgs{...} }
                                                                

                                                                type DevicePortArrayOutput

                                                                type DevicePortArrayOutput struct{ *pulumi.OutputState }

                                                                func (DevicePortArrayOutput) ElementType

                                                                func (DevicePortArrayOutput) ElementType() reflect.Type

                                                                func (DevicePortArrayOutput) Index

                                                                func (DevicePortArrayOutput) ToDevicePortArrayOutput

                                                                func (o DevicePortArrayOutput) ToDevicePortArrayOutput() DevicePortArrayOutput

                                                                func (DevicePortArrayOutput) ToDevicePortArrayOutputWithContext

                                                                func (o DevicePortArrayOutput) ToDevicePortArrayOutputWithContext(ctx context.Context) DevicePortArrayOutput

                                                                type DevicePortInput

                                                                type DevicePortInput interface {
                                                                	pulumi.Input
                                                                
                                                                	ToDevicePortOutput() DevicePortOutput
                                                                	ToDevicePortOutputWithContext(context.Context) DevicePortOutput
                                                                }

                                                                  DevicePortInput is an input type that accepts DevicePortArgs and DevicePortOutput values. You can construct a concrete instance of `DevicePortInput` via:

                                                                  DevicePortArgs{...}
                                                                  

                                                                  type DevicePortOutput

                                                                  type DevicePortOutput struct{ *pulumi.OutputState }

                                                                  func (DevicePortOutput) Bonded

                                                                    Whether this port is part of a bond in bonded network setup * `projectId`- The ID of the project the device belongs to

                                                                    func (DevicePortOutput) ElementType

                                                                    func (DevicePortOutput) ElementType() reflect.Type

                                                                    func (DevicePortOutput) Id

                                                                      ID of the port

                                                                      func (DevicePortOutput) Mac

                                                                        MAC address assigned to the port

                                                                        func (DevicePortOutput) Name

                                                                          Name of the port (e.g. `eth0`, or `bond0`)

                                                                          func (DevicePortOutput) ToDevicePortOutput

                                                                          func (o DevicePortOutput) ToDevicePortOutput() DevicePortOutput

                                                                          func (DevicePortOutput) ToDevicePortOutputWithContext

                                                                          func (o DevicePortOutput) ToDevicePortOutputWithContext(ctx context.Context) DevicePortOutput

                                                                          func (DevicePortOutput) Type

                                                                            One of [`privateIpv4`, `publicIpv4`, `publicIpv6`]

                                                                            type DevicePtrInput

                                                                            type DevicePtrInput interface {
                                                                            	pulumi.Input
                                                                            
                                                                            	ToDevicePtrOutput() DevicePtrOutput
                                                                            	ToDevicePtrOutputWithContext(ctx context.Context) DevicePtrOutput
                                                                            }

                                                                            type DevicePtrOutput

                                                                            type DevicePtrOutput struct {
                                                                            	*pulumi.OutputState
                                                                            }

                                                                            func (DevicePtrOutput) ElementType

                                                                            func (DevicePtrOutput) ElementType() reflect.Type

                                                                            func (DevicePtrOutput) ToDevicePtrOutput

                                                                            func (o DevicePtrOutput) ToDevicePtrOutput() DevicePtrOutput

                                                                            func (DevicePtrOutput) ToDevicePtrOutputWithContext

                                                                            func (o DevicePtrOutput) ToDevicePtrOutputWithContext(ctx context.Context) DevicePtrOutput

                                                                            type DeviceState

                                                                            type DeviceState struct {
                                                                            	// The ipv4 private IP assigned to the device
                                                                            	AccessPrivateIpv4 pulumi.StringPtrInput
                                                                            	// The ipv4 maintenance IP assigned to the device
                                                                            	AccessPublicIpv4 pulumi.StringPtrInput
                                                                            	// The ipv6 maintenance IP assigned to the device
                                                                            	AccessPublicIpv6 pulumi.StringPtrInput
                                                                            	// If true, a device with OS `customIpxe` will
                                                                            	// continue to boot via iPXE on reboots.
                                                                            	AlwaysPxe pulumi.BoolPtrInput
                                                                            	// monthly or hourly
                                                                            	BillingCycle pulumi.StringPtrInput
                                                                            	// The timestamp for when the device was created
                                                                            	Created pulumi.StringPtrInput
                                                                            	// A string of the desired Custom Data for the device.
                                                                            	CustomData pulumi.StringPtrInput
                                                                            	// The facility where the device is deployed.
                                                                            	DeployedFacility pulumi.StringPtrInput
                                                                            	// ID of hardware reservation where this device was deployed. It is useful when using the `next-available` hardware reservation.
                                                                            	DeployedHardwareReservationId pulumi.StringPtrInput
                                                                            	// Description string for the device
                                                                            	Description pulumi.StringPtrInput
                                                                            	// List of facility codes with deployment preferences. Equinix Metal API will go through the list and will deploy your device to first facility with free capacity. List items must be facility codes or `any` (a wildcard). To find the facility code, visit [Facilities API docs](https://metal.equinix.com/developers/api/facilities/), set your API auth token in the top of the page and see JSON from the API response.
                                                                            	Facilities pulumi.StringArrayInput
                                                                            	// Delete device even if it has volumes attached. Only applies for destroy action.
                                                                            	ForceDetachVolumes    pulumi.BoolPtrInput
                                                                            	HardwareReservationId pulumi.StringPtrInput
                                                                            	// The device name
                                                                            	Hostname pulumi.StringPtrInput
                                                                            	// A list of IP address types for the device (structure is documented below).
                                                                            	IpAddresses DeviceIpAddressArrayInput
                                                                            	// URL pointing to a hosted iPXE script. More
                                                                            	// information is in the
                                                                            	// [Custom iPXE](https://metal.equinix.com/developers/docs/servers/custom-ipxe/)
                                                                            	// doc.
                                                                            	IpxeScriptUrl pulumi.StringPtrInput
                                                                            	// Whether the device is locked
                                                                            	Locked pulumi.BoolPtrInput
                                                                            	// Deprecated: You should handle Network Type with the new metal_device_network_type resource.
                                                                            	NetworkType pulumi.StringPtrInput
                                                                            	// The device's private and public IP (v4 and v6) network details. When a device is run without any special network configuration, it will have 3 networks:
                                                                            	// * Public IPv4 at `metal_device.name.network.0`
                                                                            	// * IPv6 at `metal_device.name.network.1`
                                                                            	// * Private IPv4 at `metal_device.name.network.2`
                                                                            	//   Elastic addresses then stack by type - an assigned public IPv4 will go after the management public IPv4 (to index 1), and will then shift the indices of the IPv6 and private IPv4. Assigned private IPv4 will go after the management private IPv4 (to the end of the network list).
                                                                            	//   The fields of the network attributes are:
                                                                            	Networks DeviceNetworkArrayInput
                                                                            	// The operating system slug. To find the slug, or visit [Operating Systems API docs](https://metal.equinix.com/developers/api/operatingsystems), set your API auth token in the top of the page and see JSON from the API response.
                                                                            	OperatingSystem pulumi.StringPtrInput
                                                                            	// The device plan slug. To find the plan slug, visit [Device plans API docs](https://metal.equinix.com/developers/api/plans), set your auth token in the top of the page and see JSON from the API response.
                                                                            	Plan pulumi.StringPtrInput
                                                                            	// Ports assigned to the device
                                                                            	Ports DevicePortArrayInput
                                                                            	// The ID of the project in which to create the device
                                                                            	ProjectId pulumi.StringPtrInput
                                                                            	// Array of IDs of the project SSH keys which should be added to the device. If you omit this, SSH keys of all the members of the parent project will be added to the device. If you specify this array, only the listed project SSH keys will be added. Project SSH keys can be created with the ProjectSshKey resource.
                                                                            	ProjectSshKeyIds pulumi.StringArrayInput
                                                                            	// Root password to the server (disabled after 24 hours)
                                                                            	RootPassword pulumi.StringPtrInput
                                                                            	// List of IDs of SSH keys deployed in the device, can be both user and project SSH keys
                                                                            	SshKeyIds pulumi.StringArrayInput
                                                                            	// The status of the device
                                                                            	State pulumi.StringPtrInput
                                                                            	// JSON for custom partitioning. Only usable on reserved hardware. More information in in the [Custom Partitioning and RAID](https://metal.equinix.com/developers/docs/servers/custom-partitioning-raid/) doc.
                                                                            	// * Please note that the disks.partitions.size attribute must be a string, not an integer. It can be a number string, or size notation string, e.g. "4G" or "8M" (for gigabytes and megabytes).
                                                                            	Storage pulumi.StringPtrInput
                                                                            	// Tags attached to the device
                                                                            	Tags pulumi.StringArrayInput
                                                                            	// The timestamp for the last time the device was updated
                                                                            	Updated pulumi.StringPtrInput
                                                                            	// A string of the desired User Data for the device.
                                                                            	UserData pulumi.StringPtrInput
                                                                            	// Only used for devices in reserved hardware. If set, the deletion of this device will block until the hardware reservation is marked provisionable (about 4 minutes in August 2019).
                                                                            	WaitForReservationDeprovision pulumi.BoolPtrInput
                                                                            }

                                                                            func (DeviceState) ElementType

                                                                            func (DeviceState) ElementType() reflect.Type

                                                                            type Facility

                                                                            type Facility pulumi.String

                                                                            func (Facility) ElementType

                                                                            func (Facility) ElementType() reflect.Type

                                                                            func (Facility) ToStringOutput

                                                                            func (e Facility) ToStringOutput() pulumi.StringOutput

                                                                            func (Facility) ToStringOutputWithContext

                                                                            func (e Facility) ToStringOutputWithContext(ctx context.Context) pulumi.StringOutput

                                                                            func (Facility) ToStringPtrOutput

                                                                            func (e Facility) ToStringPtrOutput() pulumi.StringPtrOutput

                                                                            func (Facility) ToStringPtrOutputWithContext

                                                                            func (e Facility) ToStringPtrOutputWithContext(ctx context.Context) pulumi.StringPtrOutput

                                                                            type GetDeviceBgpNeighborsArgs

                                                                            type GetDeviceBgpNeighborsArgs struct {
                                                                            	// UUID of BGP-enabled device whose neighbors to list
                                                                            	DeviceId string `pulumi:"deviceId"`
                                                                            }

                                                                              A collection of arguments for invoking getDeviceBgpNeighbors.

                                                                              type GetDeviceBgpNeighborsBgpNeighbor

                                                                              type GetDeviceBgpNeighborsBgpNeighbor struct {
                                                                              	// IP address version, 4 or 6
                                                                              	AddressFamily int `pulumi:"addressFamily"`
                                                                              	// Local autonomous system number
                                                                              	CustomerAs int `pulumi:"customerAs"`
                                                                              	// Local used peer IP address
                                                                              	CustomerIp string `pulumi:"customerIp"`
                                                                              	// Whether BGP session is password enabled
                                                                              	Md5Enabled bool `pulumi:"md5Enabled"`
                                                                              	// BGP session password in plaintext (not a checksum)
                                                                              	Md5Password string `pulumi:"md5Password"`
                                                                              	// Whether the neighbor is in EBGP multihop session
                                                                              	Multihop bool `pulumi:"multihop"`
                                                                              	// Peer AS number (different than customerAs for EBGP)
                                                                              	PeerAs int `pulumi:"peerAs"`
                                                                              	// Array of IP addresses of this neighbor's peers
                                                                              	PeerIps []string `pulumi:"peerIps"`
                                                                              	// Array of incoming routes. Each route has attributes:
                                                                              	RoutesIns []GetDeviceBgpNeighborsBgpNeighborRoutesIn `pulumi:"routesIns"`
                                                                              	// Array of outgoing routes in the same format
                                                                              	RoutesOuts []GetDeviceBgpNeighborsBgpNeighborRoutesOut `pulumi:"routesOuts"`
                                                                              }

                                                                              type GetDeviceBgpNeighborsBgpNeighborArgs

                                                                              type GetDeviceBgpNeighborsBgpNeighborArgs struct {
                                                                              	// IP address version, 4 or 6
                                                                              	AddressFamily pulumi.IntInput `pulumi:"addressFamily"`
                                                                              	// Local autonomous system number
                                                                              	CustomerAs pulumi.IntInput `pulumi:"customerAs"`
                                                                              	// Local used peer IP address
                                                                              	CustomerIp pulumi.StringInput `pulumi:"customerIp"`
                                                                              	// Whether BGP session is password enabled
                                                                              	Md5Enabled pulumi.BoolInput `pulumi:"md5Enabled"`
                                                                              	// BGP session password in plaintext (not a checksum)
                                                                              	Md5Password pulumi.StringInput `pulumi:"md5Password"`
                                                                              	// Whether the neighbor is in EBGP multihop session
                                                                              	Multihop pulumi.BoolInput `pulumi:"multihop"`
                                                                              	// Peer AS number (different than customerAs for EBGP)
                                                                              	PeerAs pulumi.IntInput `pulumi:"peerAs"`
                                                                              	// Array of IP addresses of this neighbor's peers
                                                                              	PeerIps pulumi.StringArrayInput `pulumi:"peerIps"`
                                                                              	// Array of incoming routes. Each route has attributes:
                                                                              	RoutesIns GetDeviceBgpNeighborsBgpNeighborRoutesInArrayInput `pulumi:"routesIns"`
                                                                              	// Array of outgoing routes in the same format
                                                                              	RoutesOuts GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayInput `pulumi:"routesOuts"`
                                                                              }

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArgs) ElementType

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArgs) ToGetDeviceBgpNeighborsBgpNeighborOutput

                                                                              func (i GetDeviceBgpNeighborsBgpNeighborArgs) ToGetDeviceBgpNeighborsBgpNeighborOutput() GetDeviceBgpNeighborsBgpNeighborOutput

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArgs) ToGetDeviceBgpNeighborsBgpNeighborOutputWithContext

                                                                              func (i GetDeviceBgpNeighborsBgpNeighborArgs) ToGetDeviceBgpNeighborsBgpNeighborOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborOutput

                                                                              type GetDeviceBgpNeighborsBgpNeighborArray

                                                                              type GetDeviceBgpNeighborsBgpNeighborArray []GetDeviceBgpNeighborsBgpNeighborInput

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArray) ElementType

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArray) ToGetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                              func (i GetDeviceBgpNeighborsBgpNeighborArray) ToGetDeviceBgpNeighborsBgpNeighborArrayOutput() GetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                              func (GetDeviceBgpNeighborsBgpNeighborArray) ToGetDeviceBgpNeighborsBgpNeighborArrayOutputWithContext

                                                                              func (i GetDeviceBgpNeighborsBgpNeighborArray) ToGetDeviceBgpNeighborsBgpNeighborArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                              type GetDeviceBgpNeighborsBgpNeighborArrayInput

                                                                              type GetDeviceBgpNeighborsBgpNeighborArrayInput interface {
                                                                              	pulumi.Input
                                                                              
                                                                              	ToGetDeviceBgpNeighborsBgpNeighborArrayOutput() GetDeviceBgpNeighborsBgpNeighborArrayOutput
                                                                              	ToGetDeviceBgpNeighborsBgpNeighborArrayOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborArrayOutput
                                                                              }

                                                                                GetDeviceBgpNeighborsBgpNeighborArrayInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborArray and GetDeviceBgpNeighborsBgpNeighborArrayOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborArrayInput` via:

                                                                                GetDeviceBgpNeighborsBgpNeighborArray{ GetDeviceBgpNeighborsBgpNeighborArgs{...} }
                                                                                

                                                                                type GetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                                type GetDeviceBgpNeighborsBgpNeighborArrayOutput struct{ *pulumi.OutputState }

                                                                                func (GetDeviceBgpNeighborsBgpNeighborArrayOutput) ElementType

                                                                                func (GetDeviceBgpNeighborsBgpNeighborArrayOutput) Index

                                                                                func (GetDeviceBgpNeighborsBgpNeighborArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                                func (o GetDeviceBgpNeighborsBgpNeighborArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborArrayOutput() GetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                                func (GetDeviceBgpNeighborsBgpNeighborArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborArrayOutputWithContext

                                                                                func (o GetDeviceBgpNeighborsBgpNeighborArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborArrayOutput

                                                                                type GetDeviceBgpNeighborsBgpNeighborInput

                                                                                type GetDeviceBgpNeighborsBgpNeighborInput interface {
                                                                                	pulumi.Input
                                                                                
                                                                                	ToGetDeviceBgpNeighborsBgpNeighborOutput() GetDeviceBgpNeighborsBgpNeighborOutput
                                                                                	ToGetDeviceBgpNeighborsBgpNeighborOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborOutput
                                                                                }

                                                                                  GetDeviceBgpNeighborsBgpNeighborInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborArgs and GetDeviceBgpNeighborsBgpNeighborOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborInput` via:

                                                                                  GetDeviceBgpNeighborsBgpNeighborArgs{...}
                                                                                  

                                                                                  type GetDeviceBgpNeighborsBgpNeighborOutput

                                                                                  type GetDeviceBgpNeighborsBgpNeighborOutput struct{ *pulumi.OutputState }

                                                                                  func (GetDeviceBgpNeighborsBgpNeighborOutput) AddressFamily

                                                                                    IP address version, 4 or 6

                                                                                    func (GetDeviceBgpNeighborsBgpNeighborOutput) CustomerAs

                                                                                      Local autonomous system number

                                                                                      func (GetDeviceBgpNeighborsBgpNeighborOutput) CustomerIp

                                                                                        Local used peer IP address

                                                                                        func (GetDeviceBgpNeighborsBgpNeighborOutput) ElementType

                                                                                        func (GetDeviceBgpNeighborsBgpNeighborOutput) Md5Enabled

                                                                                          Whether BGP session is password enabled

                                                                                          func (GetDeviceBgpNeighborsBgpNeighborOutput) Md5Password

                                                                                            BGP session password in plaintext (not a checksum)

                                                                                            func (GetDeviceBgpNeighborsBgpNeighborOutput) Multihop

                                                                                              Whether the neighbor is in EBGP multihop session

                                                                                              func (GetDeviceBgpNeighborsBgpNeighborOutput) PeerAs

                                                                                                Peer AS number (different than customerAs for EBGP)

                                                                                                func (GetDeviceBgpNeighborsBgpNeighborOutput) PeerIps

                                                                                                  Array of IP addresses of this neighbor's peers

                                                                                                  func (GetDeviceBgpNeighborsBgpNeighborOutput) RoutesIns

                                                                                                    Array of incoming routes. Each route has attributes:

                                                                                                    func (GetDeviceBgpNeighborsBgpNeighborOutput) RoutesOuts

                                                                                                      Array of outgoing routes in the same format

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborOutput) ToGetDeviceBgpNeighborsBgpNeighborOutput

                                                                                                      func (o GetDeviceBgpNeighborsBgpNeighborOutput) ToGetDeviceBgpNeighborsBgpNeighborOutput() GetDeviceBgpNeighborsBgpNeighborOutput

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborOutput) ToGetDeviceBgpNeighborsBgpNeighborOutputWithContext

                                                                                                      func (o GetDeviceBgpNeighborsBgpNeighborOutput) ToGetDeviceBgpNeighborsBgpNeighborOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborOutput

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesIn

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesIn struct {
                                                                                                      	// (bool) Whether the route is exact
                                                                                                      	Exact bool `pulumi:"exact"`
                                                                                                      	// CIDR expression of route (IP/mask)
                                                                                                      	Route string `pulumi:"route"`
                                                                                                      }

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArgs

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArgs struct {
                                                                                                      	// (bool) Whether the route is exact
                                                                                                      	Exact pulumi.BoolInput `pulumi:"exact"`
                                                                                                      	// CIDR expression of route (IP/mask)
                                                                                                      	Route pulumi.StringInput `pulumi:"route"`
                                                                                                      }

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArgs) ElementType

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                      func (i GetDeviceBgpNeighborsBgpNeighborRoutesInArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutputWithContext

                                                                                                      func (i GetDeviceBgpNeighborsBgpNeighborRoutesInArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArray

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArray []GetDeviceBgpNeighborsBgpNeighborRoutesInInput

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArray) ElementType

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                      func (i GetDeviceBgpNeighborsBgpNeighborRoutesInArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesInArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutputWithContext

                                                                                                      func (i GetDeviceBgpNeighborsBgpNeighborRoutesInArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArrayInput

                                                                                                      type GetDeviceBgpNeighborsBgpNeighborRoutesInArrayInput interface {
                                                                                                      	pulumi.Input
                                                                                                      
                                                                                                      	ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput
                                                                                                      	ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput
                                                                                                      }

                                                                                                        GetDeviceBgpNeighborsBgpNeighborRoutesInArrayInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborRoutesInArray and GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborRoutesInArrayInput` via:

                                                                                                        GetDeviceBgpNeighborsBgpNeighborRoutesInArray{ GetDeviceBgpNeighborsBgpNeighborRoutesInArgs{...} }
                                                                                                        

                                                                                                        type GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                        type GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput struct{ *pulumi.OutputState }

                                                                                                        func (GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) ElementType

                                                                                                        func (GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) Index

                                                                                                        func (GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                        func (o GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                        func (GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutputWithContext

                                                                                                        func (o GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                        type GetDeviceBgpNeighborsBgpNeighborRoutesInInput

                                                                                                        type GetDeviceBgpNeighborsBgpNeighborRoutesInInput interface {
                                                                                                        	pulumi.Input
                                                                                                        
                                                                                                        	ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInOutput
                                                                                                        	ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInOutput
                                                                                                        }

                                                                                                          GetDeviceBgpNeighborsBgpNeighborRoutesInInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborRoutesInArgs and GetDeviceBgpNeighborsBgpNeighborRoutesInOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborRoutesInInput` via:

                                                                                                          GetDeviceBgpNeighborsBgpNeighborRoutesInArgs{...}
                                                                                                          

                                                                                                          type GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                          type GetDeviceBgpNeighborsBgpNeighborRoutesInOutput struct{ *pulumi.OutputState }

                                                                                                          func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) ElementType

                                                                                                          func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Exact

                                                                                                            (bool) Whether the route is exact

                                                                                                            func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Route

                                                                                                              CIDR expression of route (IP/mask)

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                              func (o GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutput() GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutputWithContext

                                                                                                              func (o GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesInOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOut

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOut struct {
                                                                                                              	// (bool) Whether the route is exact
                                                                                                              	Exact bool `pulumi:"exact"`
                                                                                                              	// CIDR expression of route (IP/mask)
                                                                                                              	Route string `pulumi:"route"`
                                                                                                              }

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs struct {
                                                                                                              	// (bool) Whether the route is exact
                                                                                                              	Exact pulumi.BoolInput `pulumi:"exact"`
                                                                                                              	// CIDR expression of route (IP/mask)
                                                                                                              	Route pulumi.StringInput `pulumi:"route"`
                                                                                                              }

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs) ElementType

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                              func (i GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutputWithContext

                                                                                                              func (i GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArray

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArray []GetDeviceBgpNeighborsBgpNeighborRoutesOutInput

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArray) ElementType

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                              func (i GetDeviceBgpNeighborsBgpNeighborRoutesOutArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                              func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutputWithContext

                                                                                                              func (i GetDeviceBgpNeighborsBgpNeighborRoutesOutArray) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayInput

                                                                                                              type GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayInput interface {
                                                                                                              	pulumi.Input
                                                                                                              
                                                                                                              	ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput
                                                                                                              	ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput
                                                                                                              }

                                                                                                                GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborRoutesOutArray and GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayInput` via:

                                                                                                                GetDeviceBgpNeighborsBgpNeighborRoutesOutArray{ GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs{...} }
                                                                                                                

                                                                                                                type GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                                type GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput struct{ *pulumi.OutputState }

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ElementType

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) Index

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutputWithContext

                                                                                                                func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                                type GetDeviceBgpNeighborsBgpNeighborRoutesOutInput

                                                                                                                type GetDeviceBgpNeighborsBgpNeighborRoutesOutInput interface {
                                                                                                                	pulumi.Input
                                                                                                                
                                                                                                                	ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput
                                                                                                                	ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutputWithContext(context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput
                                                                                                                }

                                                                                                                  GetDeviceBgpNeighborsBgpNeighborRoutesOutInput is an input type that accepts GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs and GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput values. You can construct a concrete instance of `GetDeviceBgpNeighborsBgpNeighborRoutesOutInput` via:

                                                                                                                  GetDeviceBgpNeighborsBgpNeighborRoutesOutArgs{...}
                                                                                                                  

                                                                                                                  type GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                                  type GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput struct{ *pulumi.OutputState }

                                                                                                                  func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) ElementType

                                                                                                                  func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Exact

                                                                                                                    (bool) Whether the route is exact

                                                                                                                    func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Route

                                                                                                                      CIDR expression of route (IP/mask)

                                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                                      func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                                      func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutputWithContext

                                                                                                                      func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutOutputWithContext(ctx context.Context) GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                                      type GetDeviceBgpNeighborsResult

                                                                                                                      type GetDeviceBgpNeighborsResult struct {
                                                                                                                      	// array of BGP neighbor records with attributes:
                                                                                                                      	BgpNeighbors []GetDeviceBgpNeighborsBgpNeighbor `pulumi:"bgpNeighbors"`
                                                                                                                      	DeviceId     string                             `pulumi:"deviceId"`
                                                                                                                      	// The provider-assigned unique ID for this managed resource.
                                                                                                                      	Id string `pulumi:"id"`
                                                                                                                      }

                                                                                                                        A collection of values returned by getDeviceBgpNeighbors.

                                                                                                                        func GetDeviceBgpNeighbors

                                                                                                                        func GetDeviceBgpNeighbors(ctx *pulumi.Context, args *GetDeviceBgpNeighborsArgs, opts ...pulumi.InvokeOption) (*GetDeviceBgpNeighborsResult, error)

                                                                                                                          Use this datasource to retrieve list of BGP neighbors of a device in the Equinix Metal host.

                                                                                                                          To have any BGP neighbors listed, the device must be in BGP-enabled project and have a BGP session assigned.

                                                                                                                          To learn more about using BGP in Equinix Metal, see the BgpSession resource documentation.

                                                                                                                          ## Example Usage

                                                                                                                          “`go package main

                                                                                                                          import (

                                                                                                                          "github.com/pulumi/pulumi-equinix-metal/sdk/go/equinix-metal"
                                                                                                                          "github.com/pulumi/pulumi/sdk/v2/go/pulumi"
                                                                                                                          

                                                                                                                          )

                                                                                                                          func main() {

                                                                                                                          pulumi.Run(func(ctx *pulumi.Context) error {
                                                                                                                          	test, err := equinix - metal.GetDeviceBgpNeighbors(ctx, &equinix-metal.GetDeviceBgpNeighborsArgs{
                                                                                                                          		DeviceId: "4c641195-25e5-4c3c-b2b7-4cd7a42c7b40",
                                                                                                                          	}, nil)
                                                                                                                          	if err != nil {
                                                                                                                          		return err
                                                                                                                          	}
                                                                                                                          	ctx.Export("bgpNeighborsListing", test.BgpNeighbors)
                                                                                                                          	return nil
                                                                                                                          })
                                                                                                                          

                                                                                                                          } “`

                                                                                                                          type GetDeviceNetwork

                                                                                                                          type GetDeviceNetwork struct {
                                                                                                                          	// IPv4 or IPv6 address string
                                                                                                                          	Address string `pulumi:"address"`
                                                                                                                          	// Bit length of the network mask of the address
                                                                                                                          	Cidr int `pulumi:"cidr"`
                                                                                                                          	// IP version - "4" or "6"
                                                                                                                          	Family int `pulumi:"family"`
                                                                                                                          	// Address of router
                                                                                                                          	Gateway string `pulumi:"gateway"`
                                                                                                                          	// Whether the address is routable from the Internet
                                                                                                                          	Public bool `pulumi:"public"`
                                                                                                                          }

                                                                                                                          type GetDeviceNetworkArgs

                                                                                                                          type GetDeviceNetworkArgs struct {
                                                                                                                          	// IPv4 or IPv6 address string
                                                                                                                          	Address pulumi.StringInput `pulumi:"address"`
                                                                                                                          	// Bit length of the network mask of the address
                                                                                                                          	Cidr pulumi.IntInput `pulumi:"cidr"`
                                                                                                                          	// IP version - "4" or "6"
                                                                                                                          	Family pulumi.IntInput `pulumi:"family"`
                                                                                                                          	// Address of router
                                                                                                                          	Gateway pulumi.StringInput `pulumi:"gateway"`
                                                                                                                          	// Whether the address is routable from the Internet
                                                                                                                          	Public pulumi.BoolInput `pulumi:"public"`
                                                                                                                          }

                                                                                                                          func (GetDeviceNetworkArgs) ElementType

                                                                                                                          func (GetDeviceNetworkArgs) ElementType() reflect.Type

                                                                                                                          func (GetDeviceNetworkArgs) ToGetDeviceNetworkOutput

                                                                                                                          func (i GetDeviceNetworkArgs) ToGetDeviceNetworkOutput() GetDeviceNetworkOutput

                                                                                                                          func (GetDeviceNetworkArgs) ToGetDeviceNetworkOutputWithContext

                                                                                                                          func (i GetDeviceNetworkArgs) ToGetDeviceNetworkOutputWithContext(ctx context.Context) GetDeviceNetworkOutput

                                                                                                                          type GetDeviceNetworkArray

                                                                                                                          type GetDeviceNetworkArray []GetDeviceNetworkInput

                                                                                                                          func (GetDeviceNetworkArray) ElementType

                                                                                                                          func (GetDeviceNetworkArray) ElementType() reflect.Type

                                                                                                                          func (GetDeviceNetworkArray) ToGetDeviceNetworkArrayOutput

                                                                                                                          func (i GetDeviceNetworkArray) ToGetDeviceNetworkArrayOutput() GetDeviceNetworkArrayOutput

                                                                                                                          func (GetDeviceNetworkArray) ToGetDeviceNetworkArrayOutputWithContext

                                                                                                                          func (i GetDeviceNetworkArray) ToGetDeviceNetworkArrayOutputWithContext(ctx context.Context) GetDeviceNetworkArrayOutput

                                                                                                                          type GetDeviceNetworkArrayInput

                                                                                                                          type GetDeviceNetworkArrayInput interface {
                                                                                                                          	pulumi.Input
                                                                                                                          
                                                                                                                          	ToGetDeviceNetworkArrayOutput() GetDeviceNetworkArrayOutput
                                                                                                                          	ToGetDeviceNetworkArrayOutputWithContext(context.Context) GetDeviceNetworkArrayOutput
                                                                                                                          }

                                                                                                                            GetDeviceNetworkArrayInput is an input type that accepts GetDeviceNetworkArray and GetDeviceNetworkArrayOutput values. You can construct a concrete instance of `GetDeviceNetworkArrayInput` via:

                                                                                                                            GetDeviceNetworkArray{ GetDeviceNetworkArgs{...} }
                                                                                                                            

                                                                                                                            type GetDeviceNetworkArrayOutput

                                                                                                                            type GetDeviceNetworkArrayOutput struct{ *pulumi.OutputState }

                                                                                                                            func (GetDeviceNetworkArrayOutput) ElementType

                                                                                                                            func (GetDeviceNetworkArrayOutput) Index

                                                                                                                            func (GetDeviceNetworkArrayOutput) ToGetDeviceNetworkArrayOutput

                                                                                                                            func (o GetDeviceNetworkArrayOutput) ToGetDeviceNetworkArrayOutput() GetDeviceNetworkArrayOutput

                                                                                                                            func (GetDeviceNetworkArrayOutput) ToGetDeviceNetworkArrayOutputWithContext

                                                                                                                            func (o GetDeviceNetworkArrayOutput) ToGetDeviceNetworkArrayOutputWithContext(ctx context.Context) GetDeviceNetworkArrayOutput

                                                                                                                            type GetDeviceNetworkInput

                                                                                                                            type GetDeviceNetworkInput interface {
                                                                                                                            	pulumi.Input
                                                                                                                            
                                                                                                                            	ToGetDeviceNetworkOutput() GetDeviceNetworkOutput
                                                                                                                            	ToGetDeviceNetworkOutputWithContext(context.Context) GetDeviceNetworkOutput
                                                                                                                            }

                                                                                                                              GetDeviceNetworkInput is an input type that accepts GetDeviceNetworkArgs and GetDeviceNetworkOutput values. You can construct a concrete instance of `GetDeviceNetworkInput` via:

                                                                                                                              GetDeviceNetworkArgs{...}
                                                                                                                              

                                                                                                                              type GetDeviceNetworkOutput

                                                                                                                              type GetDeviceNetworkOutput struct{ *pulumi.OutputState }

                                                                                                                              func (GetDeviceNetworkOutput) Address

                                                                                                                                IPv4 or IPv6 address string

                                                                                                                                func (GetDeviceNetworkOutput) Cidr

                                                                                                                                  Bit length of the network mask of the address

                                                                                                                                  func (GetDeviceNetworkOutput) ElementType

                                                                                                                                  func (GetDeviceNetworkOutput) ElementType() reflect.Type

                                                                                                                                  func (GetDeviceNetworkOutput) Family

                                                                                                                                    IP version - "4" or "6"

                                                                                                                                    func (GetDeviceNetworkOutput) Gateway

                                                                                                                                      Address of router

                                                                                                                                      func (GetDeviceNetworkOutput) Public

                                                                                                                                        Whether the address is routable from the Internet

                                                                                                                                        func (GetDeviceNetworkOutput) ToGetDeviceNetworkOutput

                                                                                                                                        func (o GetDeviceNetworkOutput) ToGetDeviceNetworkOutput() GetDeviceNetworkOutput

                                                                                                                                        func (GetDeviceNetworkOutput) ToGetDeviceNetworkOutputWithContext

                                                                                                                                        func (o GetDeviceNetworkOutput) ToGetDeviceNetworkOutputWithContext(ctx context.Context) GetDeviceNetworkOutput

                                                                                                                                        type GetDevicePort

                                                                                                                                        type GetDevicePort struct {
                                                                                                                                        	// Whether this port is part of a bond in bonded network setup
                                                                                                                                        	Bonded bool `pulumi:"bonded"`
                                                                                                                                        	// ID of the port
                                                                                                                                        	Id string `pulumi:"id"`
                                                                                                                                        	// MAC address assigned to the port
                                                                                                                                        	Mac string `pulumi:"mac"`
                                                                                                                                        	// Name of the port (e.g. `eth0`, or `bond0`)
                                                                                                                                        	Name string `pulumi:"name"`
                                                                                                                                        	// Type of the port (e.g. `NetworkPort` or `NetworkBondPort`)
                                                                                                                                        	Type string `pulumi:"type"`
                                                                                                                                        }

                                                                                                                                        type GetDevicePortArgs

                                                                                                                                        type GetDevicePortArgs struct {
                                                                                                                                        	// Whether this port is part of a bond in bonded network setup
                                                                                                                                        	Bonded pulumi.BoolInput `pulumi:"bonded"`
                                                                                                                                        	// ID of the port
                                                                                                                                        	Id pulumi.StringInput `pulumi:"id"`
                                                                                                                                        	// MAC address assigned to the port
                                                                                                                                        	Mac pulumi.StringInput `pulumi:"mac"`
                                                                                                                                        	// Name of the port (e.g. `eth0`, or `bond0`)
                                                                                                                                        	Name pulumi.StringInput `pulumi:"name"`
                                                                                                                                        	// Type of the port (e.g. `NetworkPort` or `NetworkBondPort`)
                                                                                                                                        	Type pulumi.StringInput `pulumi:"type"`
                                                                                                                                        }

                                                                                                                                        func (GetDevicePortArgs) ElementType

                                                                                                                                        func (GetDevicePortArgs) ElementType() reflect.Type

                                                                                                                                        func (GetDevicePortArgs) ToGetDevicePortOutput

                                                                                                                                        func (i GetDevicePortArgs) ToGetDevicePortOutput() GetDevicePortOutput

                                                                                                                                        func (GetDevicePortArgs) ToGetDevicePortOutputWithContext

                                                                                                                                        func (i GetDevicePortArgs) ToGetDevicePortOutputWithContext(ctx context.Context) GetDevicePortOutput

                                                                                                                                        type GetDevicePortArray

                                                                                                                                        type GetDevicePortArray []GetDevicePortInput

                                                                                                                                        func (GetDevicePortArray) ElementType

                                                                                                                                        func (GetDevicePortArray) ElementType() reflect.Type

                                                                                                                                        func (GetDevicePortArray) ToGetDevicePortArrayOutput

                                                                                                                                        func (i GetDevicePortArray) ToGetDevicePortArrayOutput() GetDevicePortArrayOutput

                                                                                                                                        func (GetDevicePortArray) ToGetDevicePortArrayOutputWithContext

                                                                                                                                        func (i GetDevicePortArray) ToGetDevicePortArrayOutputWithContext(ctx context.Context) GetDevicePortArrayOutput

                                                                                                                                        type GetDevicePortArrayInput

                                                                                                                                        type GetDevicePortArrayInput interface {
                                                                                                                                        	pulumi.Input
                                                                                                                                        
                                                                                                                                        	ToGetDevicePortArrayOutput() GetDevicePortArrayOutput
                                                                                                                                        	ToGetDevicePortArrayOutputWithContext(context.Context) GetDevicePortArrayOutput
                                                                                                                                        }

                                                                                                                                          GetDevicePortArrayInput is an input type that accepts GetDevicePortArray and GetDevicePortArrayOutput values. You can construct a concrete instance of `GetDevicePortArrayInput` via:

                                                                                                                                          GetDevicePortArray{ GetDevicePortArgs{...} }
                                                                                                                                          

                                                                                                                                          type GetDevicePortArrayOutput

                                                                                                                                          type GetDevicePortArrayOutput struct{ *pulumi.OutputState }

                                                                                                                                          func (GetDevicePortArrayOutput) ElementType

                                                                                                                                          func (GetDevicePortArrayOutput) ElementType() reflect.Type

                                                                                                                                          func (GetDevicePortArrayOutput) Index

                                                                                                                                          func (GetDevicePortArrayOutput) ToGetDevicePortArrayOutput

                                                                                                                                          func (o GetDevicePortArrayOutput) ToGetDevicePortArrayOutput() GetDevicePortArrayOutput

                                                                                                                                          func (GetDevicePortArrayOutput) ToGetDevicePortArrayOutputWithContext

                                                                                                                                          func (o GetDevicePortArrayOutput) ToGetDevicePortArrayOutputWithContext(ctx context.Context) GetDevicePortArrayOutput

                                                                                                                                          type GetDevicePortInput

                                                                                                                                          type GetDevicePortInput interface {
                                                                                                                                          	pulumi.Input
                                                                                                                                          
                                                                                                                                          	ToGetDevicePortOutput() GetDevicePortOutput
                                                                                                                                          	ToGetDevicePortOutputWithContext(context.Context) GetDevicePortOutput
                                                                                                                                          }

                                                                                                                                            GetDevicePortInput is an input type that accepts GetDevicePortArgs and GetDevicePortOutput values. You can construct a concrete instance of `GetDevicePortInput` via:

                                                                                                                                            GetDevicePortArgs{...}
                                                                                                                                            

                                                                                                                                            type GetDevicePortOutput

                                                                                                                                            type GetDevicePortOutput struct{ *pulumi.OutputState }

                                                                                                                                            func (GetDevicePortOutput) Bonded

                                                                                                                                              Whether this port is part of a bond in bonded network setup

                                                                                                                                              func (GetDevicePortOutput) ElementType

                                                                                                                                              func (GetDevicePortOutput) ElementType() reflect.Type

                                                                                                                                              func (GetDevicePortOutput) Id

                                                                                                                                                ID of the port

                                                                                                                                                func (GetDevicePortOutput) Mac

                                                                                                                                                  MAC address assigned to the port

                                                                                                                                                  func (GetDevicePortOutput) Name

                                                                                                                                                    Name of the port (e.g. `eth0`, or `bond0`)

                                                                                                                                                    func (GetDevicePortOutput) ToGetDevicePortOutput

                                                                                                                                                    func (o GetDevicePortOutput) ToGetDevicePortOutput() GetDevicePortOutput

                                                                                                                                                    func (GetDevicePortOutput) ToGetDevicePortOutputWithContext

                                                                                                                                                    func (o GetDevicePortOutput) ToGetDevicePortOutputWithContext(ctx context.Context) GetDevicePortOutput

                                                                                                                                                    func (GetDevicePortOutput) Type

                                                                                                                                                      Type of the port (e.g. `NetworkPort` or `NetworkBondPort`)

                                                                                                                                                      type GetIpBlockRangesArgs

                                                                                                                                                      type GetIpBlockRangesArgs struct {
                                                                                                                                                      	// Facility code filtering the IP blocks. Global IPv4 blcoks will be listed anyway. If you omit this, all the block from the project will be listed.
                                                                                                                                                      	Facility *string `pulumi:"facility"`
                                                                                                                                                      	// ID of the project from which to list the blocks.
                                                                                                                                                      	ProjectId string `pulumi:"projectId"`
                                                                                                                                                      }

                                                                                                                                                        A collection of arguments for invoking getIpBlockRanges.

                                                                                                                                                        type