nutanix.getNdbNetworkAvailableIps

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

const network = nutanix.getNdbNetworkAvailableIps({
    profileId: "{{ network_profile_id }}",
});

import pulumi
import pulumi_nutanix as nutanix

network = nutanix.get_ndb_network_available_ips(profile_id="{{ network_profile_id }}")

package main

import (
	"github.com/pierskarsenbarg/pulumi-nutanix/sdk/go/nutanix"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := nutanix.GetNdbNetworkAvailableIps(ctx, &nutanix.GetNdbNetworkAvailableIpsArgs{
			ProfileId: "{{ network_profile_id }}",
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var network = Nutanix.GetNdbNetworkAvailableIps.Invoke(new()
    {
        ProfileId = "{{ network_profile_id }}",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.nutanix.NutanixFunctions;
import com.pulumi.nutanix.inputs.GetNdbNetworkAvailableIpsArgs;
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 network = NutanixFunctions.getNdbNetworkAvailableIps(GetNdbNetworkAvailableIpsArgs.builder()
            .profileId("{{ network_profile_id }}")
            .build());

    }
}

variables:
  network:
    fn::invoke:
      Function: nutanix:getNdbNetworkAvailableIps
      Arguments:
        profileId: '{{ network_profile_id }}'

function getNdbNetworkAvailableIps(args: GetNdbNetworkAvailableIpsArgs, opts?: InvokeOptions): Promise<GetNdbNetworkAvailableIpsResult>
function getNdbNetworkAvailableIpsOutput(args: GetNdbNetworkAvailableIpsOutputArgs, opts?: InvokeOptions): Output<GetNdbNetworkAvailableIpsResult>

def get_ndb_network_available_ips(profile_id: Optional[str] = None,
                                  opts: Optional[InvokeOptions] = None) -> GetNdbNetworkAvailableIpsResult
def get_ndb_network_available_ips_output(profile_id: Optional[pulumi.Input[str]] = None,
                                  opts: Optional[InvokeOptions] = None) -> Output[GetNdbNetworkAvailableIpsResult]

func GetNdbNetworkAvailableIps(ctx *Context, args *GetNdbNetworkAvailableIpsArgs, opts ...InvokeOption) (*GetNdbNetworkAvailableIpsResult, error)
func GetNdbNetworkAvailableIpsOutput(ctx *Context, args *GetNdbNetworkAvailableIpsOutputArgs, opts ...InvokeOption) GetNdbNetworkAvailableIpsResultOutput

public static class GetNdbNetworkAvailableIps 
{
    public static Task<GetNdbNetworkAvailableIpsResult> InvokeAsync(GetNdbNetworkAvailableIpsArgs args, InvokeOptions? opts = null)
    public static Output<GetNdbNetworkAvailableIpsResult> Invoke(GetNdbNetworkAvailableIpsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetNdbNetworkAvailableIpsResult> getNdbNetworkAvailableIps(GetNdbNetworkAvailableIpsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: nutanix:index/getNdbNetworkAvailableIps:getNdbNetworkAvailableIps
  arguments:
    # arguments dictionary