netaddr.getAddressMac

import * as pulumi from "@pulumi/pulumi";
import * as netaddr from "@pulumi/netaddr";

const testRangeMac = netaddr.getRangeMac({
    keyPrefix: "/test/mac/",
});
const testAddressMac = testRangeMac.then(testRangeMac => netaddr.getAddressMac({
    rangeId: testRangeMac.id,
    name: "test",
}));
export const dataMacTest = testAddressMac.then(testAddressMac => testAddressMac.address);

import pulumi
import pulumi_netaddr as netaddr

test_range_mac = netaddr.get_range_mac(key_prefix="/test/mac/")
test_address_mac = netaddr.get_address_mac(range_id=test_range_mac.id,
    name="test")
pulumi.export("dataMacTest", test_address_mac.address)

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/netaddr/netaddr"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		testRangeMac, err := netaddr.LookupRangeMac(ctx, &netaddr.LookupRangeMacArgs{
			KeyPrefix: "/test/mac/",
		}, nil)
		if err != nil {
			return err
		}
		testAddressMac, err := netaddr.LookupAddressMac(ctx, &netaddr.LookupAddressMacArgs{
			RangeId: testRangeMac.Id,
			Name:    "test",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataMacTest", testAddressMac.Address)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Netaddr = Pulumi.Netaddr;

return await Deployment.RunAsync(() => 
{
    var testRangeMac = Netaddr.GetRangeMac.Invoke(new()
    {
        KeyPrefix = "/test/mac/",
    });

    var testAddressMac = Netaddr.GetAddressMac.Invoke(new()
    {
        RangeId = testRangeMac.Apply(getRangeMacResult => getRangeMacResult.Id),
        Name = "test",
    });

    return new Dictionary<string, object?>
    {
        ["dataMacTest"] = testAddressMac.Apply(getAddressMacResult => getAddressMacResult.Address),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.netaddr.NetaddrFunctions;
import com.pulumi.netaddr.inputs.GetRangeMacArgs;
import com.pulumi.netaddr.inputs.GetAddressMacArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var testRangeMac = NetaddrFunctions.getRangeMac(GetRangeMacArgs.builder()
            .keyPrefix("/test/mac/")
            .build());

        final var testAddressMac = NetaddrFunctions.getAddressMac(GetAddressMacArgs.builder()
            .rangeId(testRangeMac.applyValue(getRangeMacResult -> getRangeMacResult.id()))
            .name("test")
            .build());

        ctx.export("dataMacTest", testAddressMac.applyValue(getAddressMacResult -> getAddressMacResult.address()));
    }
}

variables:
  testRangeMac:
    fn::invoke:
      function: netaddr:getRangeMac
      arguments:
        keyPrefix: /test/mac/
  testAddressMac:
    fn::invoke:
      function: netaddr:getAddressMac
      arguments:
        rangeId: ${testRangeMac.id}
        name: test
outputs:
  dataMacTest: ${testAddressMac.address}

function getAddressMac(args: GetAddressMacArgs, opts?: InvokeOptions): Promise<GetAddressMacResult>
function getAddressMacOutput(args: GetAddressMacOutputArgs, opts?: InvokeOptions): Output<GetAddressMacResult>

def get_address_mac(id: Optional[str] = None,
                    name: Optional[str] = None,
                    range_id: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetAddressMacResult
def get_address_mac_output(id: Optional[pulumi.Input[str]] = None,
                    name: Optional[pulumi.Input[str]] = None,
                    range_id: Optional[pulumi.Input[str]] = None,
                    opts: Optional[InvokeOptions] = None) -> Output[GetAddressMacResult]

func LookupAddressMac(ctx *Context, args *LookupAddressMacArgs, opts ...InvokeOption) (*LookupAddressMacResult, error)
func LookupAddressMacOutput(ctx *Context, args *LookupAddressMacOutputArgs, opts ...InvokeOption) LookupAddressMacResultOutput

public static class GetAddressMac 
{
    public static Task<GetAddressMacResult> InvokeAsync(GetAddressMacArgs args, InvokeOptions? opts = null)
    public static Output<GetAddressMacResult> Invoke(GetAddressMacInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAddressMacResult> getAddressMac(GetAddressMacArgs args, InvokeOptions options)
public static Output<GetAddressMacResult> getAddressMac(GetAddressMacArgs args, InvokeOptions options)

fn::invoke:
  function: netaddr:index/getAddressMac:getAddressMac
  arguments:
    # arguments dictionary