scm.getZone

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

// Look up zone by its ID.
const scmZoneDs = scm.getZone({
    id: "50f1f0f3-a420-4989-9770-c927f1467a9a",
});
export const zoneDataSourceResults = {
    id: scmZoneDs.then(scmZoneDs => scmZoneDs.id),
    name: scmZoneDs.then(scmZoneDs => scmZoneDs.name),
    network: scmZoneDs.then(scmZoneDs => scmZoneDs.network),
    enableDeviceIdentification: scmZoneDs.then(scmZoneDs => scmZoneDs.enableDeviceIdentification),
    enableUserIdentification: scmZoneDs.then(scmZoneDs => scmZoneDs.enableUserIdentification),
    userAcl: scmZoneDs.then(scmZoneDs => scmZoneDs.userAcl),
    deviceAcl: scmZoneDs.then(scmZoneDs => scmZoneDs.deviceAcl),
    folder: scmZoneDs.then(scmZoneDs => scmZoneDs.folder),
};

import pulumi
import pulumi_scm as scm

# Look up zone by its ID.
scm_zone_ds = scm.get_zone(id="50f1f0f3-a420-4989-9770-c927f1467a9a")
pulumi.export("zoneDataSourceResults", {
    "id": scm_zone_ds.id,
    "name": scm_zone_ds.name,
    "network": scm_zone_ds.network,
    "enableDeviceIdentification": scm_zone_ds.enable_device_identification,
    "enableUserIdentification": scm_zone_ds.enable_user_identification,
    "userAcl": scm_zone_ds.user_acl,
    "deviceAcl": scm_zone_ds.device_acl,
    "folder": scm_zone_ds.folder,
})

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Look up zone by its ID.
		scmZoneDs, err := scm.LookupZone(ctx, &scm.LookupZoneArgs{
			Id: "50f1f0f3-a420-4989-9770-c927f1467a9a",
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zoneDataSourceResults", pulumi.Map{
			"id":                         scmZoneDs.Id,
			"name":                       scmZoneDs.Name,
			"network":                    scmZoneDs.Network,
			"enableDeviceIdentification": scmZoneDs.EnableDeviceIdentification,
			"enableUserIdentification":   scmZoneDs.EnableUserIdentification,
			"userAcl":                    scmZoneDs.UserAcl,
			"deviceAcl":                  scmZoneDs.DeviceAcl,
			"folder":                     scmZoneDs.Folder,
		})
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // Look up zone by its ID.
    var scmZoneDs = Scm.GetZone.Invoke(new()
    {
        Id = "50f1f0f3-a420-4989-9770-c927f1467a9a",
    });

    return new Dictionary<string, object?>
    {
        ["zoneDataSourceResults"] = 
        {
            { "id", scmZoneDs.Apply(getZoneResult => getZoneResult.Id) },
            { "name", scmZoneDs.Apply(getZoneResult => getZoneResult.Name) },
            { "network", scmZoneDs.Apply(getZoneResult => getZoneResult.Network) },
            { "enableDeviceIdentification", scmZoneDs.Apply(getZoneResult => getZoneResult.EnableDeviceIdentification) },
            { "enableUserIdentification", scmZoneDs.Apply(getZoneResult => getZoneResult.EnableUserIdentification) },
            { "userAcl", scmZoneDs.Apply(getZoneResult => getZoneResult.UserAcl) },
            { "deviceAcl", scmZoneDs.Apply(getZoneResult => getZoneResult.DeviceAcl) },
            { "folder", scmZoneDs.Apply(getZoneResult => getZoneResult.Folder) },
        },
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.scm.ScmFunctions;
import com.pulumi.scm.inputs.GetZoneArgs;
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) {
        // Look up zone by its ID.
        final var scmZoneDs = ScmFunctions.getZone(GetZoneArgs.builder()
            .id("50f1f0f3-a420-4989-9770-c927f1467a9a")
            .build());

        ctx.export("zoneDataSourceResults", Map.ofEntries(
            Map.entry("id", scmZoneDs.id()),
            Map.entry("name", scmZoneDs.name()),
            Map.entry("network", scmZoneDs.network()),
            Map.entry("enableDeviceIdentification", scmZoneDs.enableDeviceIdentification()),
            Map.entry("enableUserIdentification", scmZoneDs.enableUserIdentification()),
            Map.entry("userAcl", scmZoneDs.userAcl()),
            Map.entry("deviceAcl", scmZoneDs.deviceAcl()),
            Map.entry("folder", scmZoneDs.folder())
        ));
    }
}

variables:
  # Look up zone by its ID.
  scmZoneDs:
    fn::invoke:
      function: scm:getZone
      arguments:
        id: 50f1f0f3-a420-4989-9770-c927f1467a9a
outputs:
  # Output various attributes from the found zone to verify the lookups were successful.
  zoneDataSourceResults:
    id: ${scmZoneDs.id}
    name: ${scmZoneDs.name}
    network: ${scmZoneDs.network}
    enableDeviceIdentification: ${scmZoneDs.enableDeviceIdentification}
    enableUserIdentification: ${scmZoneDs.enableUserIdentification}
    userAcl: ${scmZoneDs.userAcl}
    deviceAcl: ${scmZoneDs.deviceAcl}
    folder: ${scmZoneDs.folder}

function getZone(args: GetZoneArgs, opts?: InvokeOptions): Promise<GetZoneResult>
function getZoneOutput(args: GetZoneOutputArgs, opts?: InvokeOptions): Output<GetZoneResult>

def get_zone(device: Optional[str] = None,
             folder: Optional[str] = None,
             id: Optional[str] = None,
             name: Optional[str] = None,
             snippet: Optional[str] = None,
             opts: Optional[InvokeOptions] = None) -> GetZoneResult
def get_zone_output(device: Optional[pulumi.Input[str]] = None,
             folder: Optional[pulumi.Input[str]] = None,
             id: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             snippet: Optional[pulumi.Input[str]] = None,
             opts: Optional[InvokeOptions] = None) -> Output[GetZoneResult]

func LookupZone(ctx *Context, args *LookupZoneArgs, opts ...InvokeOption) (*LookupZoneResult, error)
func LookupZoneOutput(ctx *Context, args *LookupZoneOutputArgs, opts ...InvokeOption) LookupZoneResultOutput

public static class GetZone 
{
    public static Task<GetZoneResult> InvokeAsync(GetZoneArgs args, InvokeOptions? opts = null)
    public static Output<GetZoneResult> Invoke(GetZoneInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetZoneResult> getZone(GetZoneArgs args, InvokeOptions options)
public static Output<GetZoneResult> getZone(GetZoneArgs args, InvokeOptions options)

fn::invoke:
  function: scm:index/getZone:getZone
  arguments:
    # arguments dictionary