openstack.networking.getAddressScope

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

const publicAddressscope = openstack.networking.getAddressScope({
    name: "public_addressscope",
    shared: true,
    ipVersion: 4,
});

import pulumi
import pulumi_openstack as openstack

public_addressscope = openstack.networking.get_address_scope(name="public_addressscope",
    shared=True,
    ip_version=4)

package main

import (
	"github.com/pulumi/pulumi-openstack/sdk/v5/go/openstack/networking"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := networking.LookupAddressScope(ctx, &networking.LookupAddressScopeArgs{
			Name:      pulumi.StringRef("public_addressscope"),
			Shared:    pulumi.BoolRef(true),
			IpVersion: pulumi.IntRef(4),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var publicAddressscope = OpenStack.Networking.GetAddressScope.Invoke(new()
    {
        Name = "public_addressscope",
        Shared = true,
        IpVersion = 4,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.openstack.networking.NetworkingFunctions;
import com.pulumi.openstack.networking.inputs.GetAddressScopeArgs;
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 publicAddressscope = NetworkingFunctions.getAddressScope(GetAddressScopeArgs.builder()
            .name("public_addressscope")
            .shared(true)
            .ipVersion(4)
            .build());

    }
}

variables:
  publicAddressscope:
    fn::invoke:
      Function: openstack:networking:getAddressScope
      Arguments:
        name: public_addressscope
        shared: true
        ipVersion: 4

function getAddressScope(args: GetAddressScopeArgs, opts?: InvokeOptions): Promise<GetAddressScopeResult>
function getAddressScopeOutput(args: GetAddressScopeOutputArgs, opts?: InvokeOptions): Output<GetAddressScopeResult>

def get_address_scope(ip_version: Optional[int] = None,
                      name: Optional[str] = None,
                      project_id: Optional[str] = None,
                      region: Optional[str] = None,
                      shared: Optional[bool] = None,
                      opts: Optional[InvokeOptions] = None) -> GetAddressScopeResult
def get_address_scope_output(ip_version: Optional[pulumi.Input[int]] = None,
                      name: Optional[pulumi.Input[str]] = None,
                      project_id: Optional[pulumi.Input[str]] = None,
                      region: Optional[pulumi.Input[str]] = None,
                      shared: Optional[pulumi.Input[bool]] = None,
                      opts: Optional[InvokeOptions] = None) -> Output[GetAddressScopeResult]

func LookupAddressScope(ctx *Context, args *LookupAddressScopeArgs, opts ...InvokeOption) (*LookupAddressScopeResult, error)
func LookupAddressScopeOutput(ctx *Context, args *LookupAddressScopeOutputArgs, opts ...InvokeOption) LookupAddressScopeResultOutput

public static class GetAddressScope 
{
    public static Task<GetAddressScopeResult> InvokeAsync(GetAddressScopeArgs args, InvokeOptions? opts = null)
    public static Output<GetAddressScopeResult> Invoke(GetAddressScopeInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetAddressScopeResult> getAddressScope(GetAddressScopeArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: openstack:networking/getAddressScope:getAddressScope
  arguments:
    # arguments dictionary