netaddr.getAddressIpv4

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

const testRangeIpv4 = netaddr.getRangeIpv4({
    keyPrefix: "/test/ipv4/",
});
const testAddressIpv4 = testRangeIpv4.then(testRangeIpv4 => netaddr.getAddressIpv4({
    rangeId: testRangeIpv4.id,
    name: "test",
}));
export const dataIpv4Test = testAddressIpv4.then(testAddressIpv4 => testAddressIpv4.address);

import pulumi
import pulumi_netaddr as netaddr

test_range_ipv4 = netaddr.get_range_ipv4(key_prefix="/test/ipv4/")
test_address_ipv4 = netaddr.get_address_ipv4(range_id=test_range_ipv4.id,
    name="test")
pulumi.export("dataIpv4Test", test_address_ipv4.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 {
		testRangeIpv4, err := netaddr.LookupRangeIpv4(ctx, &netaddr.LookupRangeIpv4Args{
			KeyPrefix: "/test/ipv4/",
		}, nil)
		if err != nil {
			return err
		}
		testAddressIpv4, err := netaddr.LookupAddressIpv4(ctx, &netaddr.LookupAddressIpv4Args{
			RangeId: testRangeIpv4.Id,
			Name:    "test",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("dataIpv4Test", testAddressIpv4.Address)
		return nil
	})
}

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

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

    var testAddressIpv4 = Netaddr.GetAddressIpv4.Invoke(new()
    {
        RangeId = testRangeIpv4.Apply(getRangeIpv4Result => getRangeIpv4Result.Id),
        Name = "test",
    });

    return new Dictionary<string, object?>
    {
        ["dataIpv4Test"] = testAddressIpv4.Apply(getAddressIpv4Result => getAddressIpv4Result.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.GetRangeIpv4Args;
import com.pulumi.netaddr.inputs.GetAddressIpv4Args;
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 testRangeIpv4 = NetaddrFunctions.getRangeIpv4(GetRangeIpv4Args.builder()
            .keyPrefix("/test/ipv4/")
            .build());

        final var testAddressIpv4 = NetaddrFunctions.getAddressIpv4(GetAddressIpv4Args.builder()
            .rangeId(testRangeIpv4.applyValue(getRangeIpv4Result -> getRangeIpv4Result.id()))
            .name("test")
            .build());

        ctx.export("dataIpv4Test", testAddressIpv4.applyValue(getAddressIpv4Result -> getAddressIpv4Result.address()));
    }
}

variables:
  testRangeIpv4:
    fn::invoke:
      function: netaddr:getRangeIpv4
      arguments:
        keyPrefix: /test/ipv4/
  testAddressIpv4:
    fn::invoke:
      function: netaddr:getAddressIpv4
      arguments:
        rangeId: ${testRangeIpv4.id}
        name: test
outputs:
  dataIpv4Test: ${testAddressIpv4.address}

function getAddressIpv4(args: GetAddressIpv4Args, opts?: InvokeOptions): Promise<GetAddressIpv4Result>
function getAddressIpv4Output(args: GetAddressIpv4OutputArgs, opts?: InvokeOptions): Output<GetAddressIpv4Result>

def get_address_ipv4(id: Optional[str] = None,
                     name: Optional[str] = None,
                     range_id: Optional[str] = None,
                     opts: Optional[InvokeOptions] = None) -> GetAddressIpv4Result
def get_address_ipv4_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[GetAddressIpv4Result]

func LookupAddressIpv4(ctx *Context, args *LookupAddressIpv4Args, opts ...InvokeOption) (*LookupAddressIpv4Result, error)
func LookupAddressIpv4Output(ctx *Context, args *LookupAddressIpv4OutputArgs, opts ...InvokeOption) LookupAddressIpv4ResultOutput

public static class GetAddressIpv4 
{
    public static Task<GetAddressIpv4Result> InvokeAsync(GetAddressIpv4Args args, InvokeOptions? opts = null)
    public static Output<GetAddressIpv4Result> Invoke(GetAddressIpv4InvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAddressIpv4Result> getAddressIpv4(GetAddressIpv4Args args, InvokeOptions options)
public static Output<GetAddressIpv4Result> getAddressIpv4(GetAddressIpv4Args args, InvokeOptions options)

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