netaddr.getRangeMac

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

const test = netaddr.getRangeMac({
    keyPrefix: "/test/mac/",
});
export const dataRangeMacTest = Promise.all([test, test]).then(([test, test1]) => `first_address: ${test.firstAddress}, last_address: ${test1.lastAddress}`);

import pulumi
import pulumi_netaddr as netaddr

test = netaddr.get_range_mac(key_prefix="/test/mac/")
pulumi.export("dataRangeMacTest", f"first_address: {test.first_address}, last_address: {test.last_address}")

package main

import (
	"fmt"

	"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 {
		test, err := netaddr.LookupRangeMac(ctx, &netaddr.LookupRangeMacArgs{
			KeyPrefix: "/test/mac/",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataRangeMacTest", pulumi.Sprintf("first_address: %v, last_address: %v", test.FirstAddress, test.LastAddress))
		return nil
	})
}

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

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

    return new Dictionary<string, object?>
    {
        ["dataRangeMacTest"] = Output.Tuple(test, test).Apply(values =>
        {
            var test = values.Item1;
            var test1 = values.Item2;
            return $"first_address: {test.Apply(getRangeMacResult => getRangeMacResult.FirstAddress)}, last_address: {test1.LastAddress}";
        }),
    };
});

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 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 test = NetaddrFunctions.getRangeMac(GetRangeMacArgs.builder()
            .keyPrefix("/test/mac/")
            .build());

        ctx.export("dataRangeMacTest", String.format("first_address: %s, last_address: %s", test.applyValue(getRangeMacResult -> getRangeMacResult.firstAddress()),test.applyValue(getRangeMacResult -> getRangeMacResult.lastAddress())));
    }
}

variables:
  test:
    fn::invoke:
      function: netaddr:getRangeMac
      arguments:
        keyPrefix: /test/mac/
outputs:
  dataRangeMacTest: 'first_address: ${test.firstAddress}, last_address: ${test.lastAddress}'

function getRangeMac(args: GetRangeMacArgs, opts?: InvokeOptions): Promise<GetRangeMacResult>
function getRangeMacOutput(args: GetRangeMacOutputArgs, opts?: InvokeOptions): Output<GetRangeMacResult>

def get_range_mac(id: Optional[str] = None,
                  key_prefix: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetRangeMacResult
def get_range_mac_output(id: Optional[pulumi.Input[str]] = None,
                  key_prefix: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetRangeMacResult]

func LookupRangeMac(ctx *Context, args *LookupRangeMacArgs, opts ...InvokeOption) (*LookupRangeMacResult, error)
func LookupRangeMacOutput(ctx *Context, args *LookupRangeMacOutputArgs, opts ...InvokeOption) LookupRangeMacResultOutput

public static class GetRangeMac 
{
    public static Task<GetRangeMacResult> InvokeAsync(GetRangeMacArgs args, InvokeOptions? opts = null)
    public static Output<GetRangeMacResult> Invoke(GetRangeMacInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRangeMacResult> getRangeMac(GetRangeMacArgs args, InvokeOptions options)
public static Output<GetRangeMacResult> getRangeMac(GetRangeMacArgs args, InvokeOptions options)

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