netaddr.getRangeUsageIpv4

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

const testRangeIpv4 = netaddr.getRangeIpv4({
    keyPrefix: "/test/ipv4/",
});
const testRangeUsageIpv4 = testRangeIpv4.then(testRangeIpv4 => netaddr.getRangeUsageIpv4({
    rangeId: testRangeIpv4.id,
}));
export const rangeCapacity = testRangeUsageIpv4.then(testRangeUsageIpv4 => testRangeUsageIpv4.capacity);
export const rangeUsedCapacity = testRangeUsageIpv4.then(testRangeUsageIpv4 => testRangeUsageIpv4.usedCapacity);
export const rangeFreeCapacity = testRangeUsageIpv4.then(testRangeUsageIpv4 => testRangeUsageIpv4.freeCapacity);

import pulumi
import pulumi_netaddr as netaddr

test_range_ipv4 = netaddr.get_range_ipv4(key_prefix="/test/ipv4/")
test_range_usage_ipv4 = netaddr.get_range_usage_ipv4(range_id=test_range_ipv4.id)
pulumi.export("rangeCapacity", test_range_usage_ipv4.capacity)
pulumi.export("rangeUsedCapacity", test_range_usage_ipv4.used_capacity)
pulumi.export("rangeFreeCapacity", test_range_usage_ipv4.free_capacity)

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
		}
		testRangeUsageIpv4, err := netaddr.GetRangeUsageIpv4(ctx, &netaddr.GetRangeUsageIpv4Args{
			RangeId: testRangeIpv4.Id,
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("rangeCapacity", testRangeUsageIpv4.Capacity)
		ctx.Export("rangeUsedCapacity", testRangeUsageIpv4.UsedCapacity)
		ctx.Export("rangeFreeCapacity", testRangeUsageIpv4.FreeCapacity)
		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 testRangeUsageIpv4 = Netaddr.GetRangeUsageIpv4.Invoke(new()
    {
        RangeId = testRangeIpv4.Apply(getRangeIpv4Result => getRangeIpv4Result.Id),
    });

    return new Dictionary<string, object?>
    {
        ["rangeCapacity"] = testRangeUsageIpv4.Apply(getRangeUsageIpv4Result => getRangeUsageIpv4Result.Capacity),
        ["rangeUsedCapacity"] = testRangeUsageIpv4.Apply(getRangeUsageIpv4Result => getRangeUsageIpv4Result.UsedCapacity),
        ["rangeFreeCapacity"] = testRangeUsageIpv4.Apply(getRangeUsageIpv4Result => getRangeUsageIpv4Result.FreeCapacity),
    };
});

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.GetRangeUsageIpv4Args;
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 testRangeUsageIpv4 = NetaddrFunctions.getRangeUsageIpv4(GetRangeUsageIpv4Args.builder()
            .rangeId(testRangeIpv4.applyValue(getRangeIpv4Result -> getRangeIpv4Result.id()))
            .build());

        ctx.export("rangeCapacity", testRangeUsageIpv4.applyValue(getRangeUsageIpv4Result -> getRangeUsageIpv4Result.capacity()));
        ctx.export("rangeUsedCapacity", testRangeUsageIpv4.applyValue(getRangeUsageIpv4Result -> getRangeUsageIpv4Result.usedCapacity()));
        ctx.export("rangeFreeCapacity", testRangeUsageIpv4.applyValue(getRangeUsageIpv4Result -> getRangeUsageIpv4Result.freeCapacity()));
    }
}

variables:
  testRangeIpv4:
    fn::invoke:
      function: netaddr:getRangeIpv4
      arguments:
        keyPrefix: /test/ipv4/
  testRangeUsageIpv4:
    fn::invoke:
      function: netaddr:getRangeUsageIpv4
      arguments:
        rangeId: ${testRangeIpv4.id}
outputs:
  rangeCapacity: ${testRangeUsageIpv4.capacity}
  rangeUsedCapacity: ${testRangeUsageIpv4.usedCapacity}
  rangeFreeCapacity: ${testRangeUsageIpv4.freeCapacity}

function getRangeUsageIpv4(args: GetRangeUsageIpv4Args, opts?: InvokeOptions): Promise<GetRangeUsageIpv4Result>
function getRangeUsageIpv4Output(args: GetRangeUsageIpv4OutputArgs, opts?: InvokeOptions): Output<GetRangeUsageIpv4Result>

def get_range_usage_ipv4(id: Optional[str] = None,
                         range_id: Optional[str] = None,
                         opts: Optional[InvokeOptions] = None) -> GetRangeUsageIpv4Result
def get_range_usage_ipv4_output(id: Optional[pulumi.Input[str]] = None,
                         range_id: Optional[pulumi.Input[str]] = None,
                         opts: Optional[InvokeOptions] = None) -> Output[GetRangeUsageIpv4Result]

func GetRangeUsageIpv4(ctx *Context, args *GetRangeUsageIpv4Args, opts ...InvokeOption) (*GetRangeUsageIpv4Result, error)
func GetRangeUsageIpv4Output(ctx *Context, args *GetRangeUsageIpv4OutputArgs, opts ...InvokeOption) GetRangeUsageIpv4ResultOutput

public static class GetRangeUsageIpv4 
{
    public static Task<GetRangeUsageIpv4Result> InvokeAsync(GetRangeUsageIpv4Args args, InvokeOptions? opts = null)
    public static Output<GetRangeUsageIpv4Result> Invoke(GetRangeUsageIpv4InvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetRangeUsageIpv4Result> getRangeUsageIpv4(GetRangeUsageIpv4Args args, InvokeOptions options)
public static Output<GetRangeUsageIpv4Result> getRangeUsageIpv4(GetRangeUsageIpv4Args args, InvokeOptions options)

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