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 (o BgpSessionArrayOutput) Index(i pulumi.IntInput) BgpSessionOutput

                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 (o BgpSessionMapOutput) MapIndex(k pulumi.StringInput) BgpSessionOutput

                  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 (o DeviceArrayOutput) Index(i pulumi.IntInput) DeviceOutput

                          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 (o DeviceIpAddressArrayOutput) Index(i pulumi.IntInput) DeviceIpAddressOutput

                            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 

                              func (o DeviceIpAddressOutput) Cidr() pulumi.IntPtrOutput

                                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 

                                  func (o DeviceIpAddressOutput) Type() pulumi.StringOutput

                                    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 (o DeviceMapOutput) MapIndex(k pulumi.StringInput) DeviceOutput

                                      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 (o DeviceNetworkArrayOutput) Index(i pulumi.IntInput) DeviceNetworkOutput

                                        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 

                                          func (o DeviceNetworkOutput) Address() pulumi.StringPtrOutput

                                            IPv4 or IPv6 address string

                                            func (DeviceNetworkOutput) Cidr 

                                            func (o DeviceNetworkOutput) Cidr() pulumi.IntPtrOutput

                                              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 

                                              func (o DeviceNetworkOutput) Family() pulumi.IntPtrOutput

                                                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 

                                                func (o DeviceNetworkOutput) Gateway() pulumi.StringPtrOutput

                                                  address of router

                                                  func (DeviceNetworkOutput) Public 

                                                  func (o DeviceNetworkOutput) Public() pulumi.BoolPtrOutput

                                                    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) ElementType() reflect.Type

                                                            func (DeviceNetworkTypeArrayOutput) Index 

                                                            func (o DeviceNetworkTypeArrayOutput) Index(i pulumi.IntInput) DeviceNetworkTypeOutput

                                                            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 (o DeviceNetworkTypeMapOutput) MapIndex(k pulumi.StringInput) DeviceNetworkTypeOutput

                                                              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 (o DevicePortArrayOutput) Index(i pulumi.IntInput) DevicePortOutput

                                                                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 

                                                                  func (o DevicePortOutput) Bonded() pulumi.BoolPtrOutput

                                                                    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 

                                                                    func (o DevicePortOutput) Id() pulumi.StringPtrOutput

                                                                      ID of the port

                                                                      func (DevicePortOutput) Mac 

                                                                      func (o DevicePortOutput) Mac() pulumi.StringPtrOutput

                                                                        MAC address assigned to the port

                                                                        func (DevicePortOutput) Name 

                                                                        func (o DevicePortOutput) Name() pulumi.StringPtrOutput

                                                                          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 

                                                                          func (o DevicePortOutput) Type() pulumi.StringPtrOutput

                                                                            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) ElementType() reflect.Type

                                                                              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) ElementType() reflect.Type

                                                                              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) ElementType() reflect.Type

                                                                                func (GetDeviceBgpNeighborsBgpNeighborArrayOutput) Index 

                                                                                func (o GetDeviceBgpNeighborsBgpNeighborArrayOutput) Index(i pulumi.IntInput) GetDeviceBgpNeighborsBgpNeighborOutput

                                                                                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 

                                                                                  func (o GetDeviceBgpNeighborsBgpNeighborOutput) AddressFamily() pulumi.IntOutput

                                                                                    IP address version, 4 or 6

                                                                                    func (GetDeviceBgpNeighborsBgpNeighborOutput) CustomerAs 

                                                                                    func (o GetDeviceBgpNeighborsBgpNeighborOutput) CustomerAs() pulumi.IntOutput

                                                                                      Local autonomous system number

                                                                                      func (GetDeviceBgpNeighborsBgpNeighborOutput) CustomerIp 

                                                                                      func (o GetDeviceBgpNeighborsBgpNeighborOutput) CustomerIp() pulumi.StringOutput

                                                                                        Local used peer IP address

                                                                                        func (GetDeviceBgpNeighborsBgpNeighborOutput) ElementType 

                                                                                        func (GetDeviceBgpNeighborsBgpNeighborOutput) ElementType() reflect.Type

                                                                                        func (GetDeviceBgpNeighborsBgpNeighborOutput) Md5Enabled 

                                                                                        func (o GetDeviceBgpNeighborsBgpNeighborOutput) Md5Enabled() pulumi.BoolOutput

                                                                                          Whether BGP session is password enabled

                                                                                          func (GetDeviceBgpNeighborsBgpNeighborOutput) Md5Password 

                                                                                          func (o GetDeviceBgpNeighborsBgpNeighborOutput) Md5Password() pulumi.StringOutput

                                                                                            BGP session password in plaintext (not a checksum)

                                                                                            func (GetDeviceBgpNeighborsBgpNeighborOutput) Multihop 

                                                                                            func (o GetDeviceBgpNeighborsBgpNeighborOutput) Multihop() pulumi.BoolOutput

                                                                                              Whether the neighbor is in EBGP multihop session

                                                                                              func (GetDeviceBgpNeighborsBgpNeighborOutput) PeerAs 

                                                                                              func (o GetDeviceBgpNeighborsBgpNeighborOutput) PeerAs() pulumi.IntOutput

                                                                                                Peer AS number (different than customerAs for EBGP)

                                                                                                func (GetDeviceBgpNeighborsBgpNeighborOutput) PeerIps 

                                                                                                func (o GetDeviceBgpNeighborsBgpNeighborOutput) PeerIps() pulumi.StringArrayOutput

                                                                                                  Array of IP addresses of this neighbor's peers

                                                                                                  func (GetDeviceBgpNeighborsBgpNeighborOutput) RoutesIns 

                                                                                                  func (o GetDeviceBgpNeighborsBgpNeighborOutput) RoutesIns() GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput

                                                                                                    Array of incoming routes. Each route has attributes:

                                                                                                    func (GetDeviceBgpNeighborsBgpNeighborOutput) RoutesOuts 

                                                                                                    func (o GetDeviceBgpNeighborsBgpNeighborOutput) RoutesOuts() GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                      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) ElementType() reflect.Type

                                                                                                      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) ElementType() reflect.Type

                                                                                                      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) ElementType() reflect.Type

                                                                                                        func (GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) Index 

                                                                                                        func (o GetDeviceBgpNeighborsBgpNeighborRoutesInArrayOutput) Index(i pulumi.IntInput) GetDeviceBgpNeighborsBgpNeighborRoutesInOutput

                                                                                                        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) ElementType() reflect.Type

                                                                                                          func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Exact 

                                                                                                          func (o GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Exact() pulumi.BoolOutput

                                                                                                            (bool) Whether the route is exact

                                                                                                            func (GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Route 

                                                                                                            func (o GetDeviceBgpNeighborsBgpNeighborRoutesInOutput) Route() pulumi.StringOutput

                                                                                                              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) ElementType() reflect.Type

                                                                                                              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) ElementType() reflect.Type

                                                                                                              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) ElementType() reflect.Type

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) Index 

                                                                                                                func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) Index(i pulumi.IntInput) GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput

                                                                                                                func (GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput 

                                                                                                                func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput) ToGetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput() GetDeviceBgpNeighborsBgpNeighborRoutesOutArrayOutput

                                                                                                                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) ElementType() reflect.Type

                                                                                                                  func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Exact 

                                                                                                                  func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Exact() pulumi.BoolOutput

                                                                                                                    (bool) Whether the route is exact

                                                                                                                    func (GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Route 

                                                                                                                    func (o GetDeviceBgpNeighborsBgpNeighborRoutesOutOutput) Route() pulumi.StringOutput

                                                                                                                      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) ElementType() reflect.Type

                                                                                                                            func (GetDeviceNetworkArrayOutput) Index 

                                                                                                                            func (o GetDeviceNetworkArrayOutput) Index(i pulumi.IntInput) GetDeviceNetworkOutput

                                                                                                                            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 

                                                                                                                              func (o GetDeviceNetworkOutput) Address() pulumi.StringOutput

                                                                                                                                IPv4 or IPv6 address string

                                                                                                                                func (GetDeviceNetworkOutput) Cidr 

                                                                                                                                func (o GetDeviceNetworkOutput) Cidr() pulumi.IntOutput

                                                                                                                                  Bit length of the network mask of the address

                                                                                                                                  func (GetDeviceNetworkOutput) ElementType 

                                                                                                                                  func (GetDeviceNetworkOutput) ElementType() reflect.Type

                                                                                                                                  func (GetDeviceNetworkOutput) Family 

                                                                                                                                  func (o GetDeviceNetworkOutput) Family() pulumi.IntOutput

                                                                                                                                    IP version - "4" or "6"

                                                                                                                                    func (GetDeviceNetworkOutput) Gateway 

                                                                                                                                    func (o GetDeviceNetworkOutput) Gateway() pulumi.StringOutput

                                                                                                                                      Address of router

                                                                                                                                      func (GetDeviceNetworkOutput) Public 

                                                                                                                                      func (o GetDeviceNetworkOutput) Public() pulumi.BoolOutput

                                                                                                                                        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 (o GetDevicePortArrayOutput) Index(i pulumi.IntInput) GetDevicePortOutput

                                                                                                                                          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 

                                                                                                                                            func (o GetDevicePortOutput) Bonded() pulumi.BoolOutput

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

                                                                                                                                              func (GetDevicePortOutput) ElementType 

                                                                                                                                              func (GetDevicePortOutput) ElementType() reflect.Type

                                                                                                                                              func (GetDevicePortOutput) Id 

                                                                                                                                              func (o GetDevicePortOutput) Id() pulumi.StringOutput

                                                                                                                                                ID of the port

                                                                                                                                                func (GetDevicePortOutput) Mac 

                                                                                                                                                func (o GetDevicePortOutput) Mac() pulumi.StringOutput

                                                                                                                                                  MAC address assigned to the port

                                                                                                                                                  func (GetDevicePortOutput) Name 

                                                                                                                                                  func (o GetDevicePortOutput) Name() pulumi.StringOutput

                                                                                                                                                    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 

                                                                                                                                                    func (o GetDevicePortOutput) Type() pulumi.StringOutput

                                                                                                                                                      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