zpa.getPolicyType

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "ACCESS_POLICY" ID
const accessPolicy = zpa.getPolicyType({
    policyType: "ACCESS_POLICY",
});
export const zpaPolicyTypeAccessPolicy = accessPolicy.then(accessPolicy => accessPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "ACCESS_POLICY" ID
access_policy = zpa.get_policy_type(policy_type="ACCESS_POLICY")
pulumi.export("zpaPolicyTypeAccessPolicy", access_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "ACCESS_POLICY" ID
		accessPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("ACCESS_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeAccessPolicy", accessPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "ACCESS_POLICY" ID
    var accessPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "ACCESS_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeAccessPolicy"] = accessPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "ACCESS_POLICY" ID
        final var accessPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("ACCESS_POLICY")
            .build());

        ctx.export("zpaPolicyTypeAccessPolicy", accessPolicy.id());
    }
}

variables:
  # Get information for "ACCESS_POLICY" ID
  accessPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: ACCESS_POLICY
outputs:
  zpaPolicyTypeAccessPolicy: ${accessPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "accessPolicy" {
  policy_type = "ACCESS_POLICY"
}

# Get information for "ACCESS_POLICY" ID
output "zpaPolicyTypeAccessPolicy" {
  value = data.zpa_getpolicytype.accessPolicy.id
}

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "GLOBAL_POLICY" ID
const globalPolicy = zpa.getPolicyType({
    policyType: "GLOBAL_POLICY",
});
export const zpaPolicyTypeAccessPolicy = globalPolicy.then(globalPolicy => globalPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "GLOBAL_POLICY" ID
global_policy = zpa.get_policy_type(policy_type="GLOBAL_POLICY")
pulumi.export("zpaPolicyTypeAccessPolicy", global_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "GLOBAL_POLICY" ID
		globalPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("GLOBAL_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeAccessPolicy", globalPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "GLOBAL_POLICY" ID
    var globalPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "GLOBAL_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeAccessPolicy"] = globalPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "GLOBAL_POLICY" ID
        final var globalPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("GLOBAL_POLICY")
            .build());

        ctx.export("zpaPolicyTypeAccessPolicy", globalPolicy.id());
    }
}

variables:
  # Get information for "GLOBAL_POLICY" ID
  globalPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: GLOBAL_POLICY
outputs:
  zpaPolicyTypeAccessPolicy: ${globalPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "globalPolicy" {
  policy_type = "GLOBAL_POLICY"
}

# Get information for "GLOBAL_POLICY" ID
output "zpaPolicyTypeAccessPolicy" {
  value = data.zpa_getpolicytype.globalPolicy.id
}

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "TIMEOUT_POLICY" ID
const timeoutPolicy = zpa.getPolicyType({
    policyType: "TIMEOUT_POLICY",
});
export const zpaPolicyTypeTimeoutPolicy = timeoutPolicy.then(timeoutPolicy => timeoutPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "TIMEOUT_POLICY" ID
timeout_policy = zpa.get_policy_type(policy_type="TIMEOUT_POLICY")
pulumi.export("zpaPolicyTypeTimeoutPolicy", timeout_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "TIMEOUT_POLICY" ID
		timeoutPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("TIMEOUT_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeTimeoutPolicy", timeoutPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "TIMEOUT_POLICY" ID
    var timeoutPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "TIMEOUT_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeTimeoutPolicy"] = timeoutPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "TIMEOUT_POLICY" ID
        final var timeoutPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("TIMEOUT_POLICY")
            .build());

        ctx.export("zpaPolicyTypeTimeoutPolicy", timeoutPolicy.id());
    }
}

variables:
  # Get information for "TIMEOUT_POLICY" ID
  timeoutPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: TIMEOUT_POLICY
outputs:
  zpaPolicyTypeTimeoutPolicy: ${timeoutPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "timeoutPolicy" {
  policy_type = "TIMEOUT_POLICY"
}

# Get information for "TIMEOUT_POLICY" ID
output "zpaPolicyTypeTimeoutPolicy" {
  value = data.zpa_getpolicytype.timeoutPolicy.id
}

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "REAUTH_POLICY" ID
const reauthPolicy = zpa.getPolicyType({
    policyType: "REAUTH_POLICY",
});
export const zpaPolicyTypeReauthPolicy = reauthPolicy.then(reauthPolicy => reauthPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "REAUTH_POLICY" ID
reauth_policy = zpa.get_policy_type(policy_type="REAUTH_POLICY")
pulumi.export("zpaPolicyTypeReauthPolicy", reauth_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "REAUTH_POLICY" ID
		reauthPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("REAUTH_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeReauthPolicy", reauthPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "REAUTH_POLICY" ID
    var reauthPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "REAUTH_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeReauthPolicy"] = reauthPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "REAUTH_POLICY" ID
        final var reauthPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("REAUTH_POLICY")
            .build());

        ctx.export("zpaPolicyTypeReauthPolicy", reauthPolicy.id());
    }
}

variables:
  # Get information for "REAUTH_POLICY" ID
  reauthPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: REAUTH_POLICY
outputs:
  zpaPolicyTypeReauthPolicy: ${reauthPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "reauthPolicy" {
  policy_type = "REAUTH_POLICY"
}

# Get information for "REAUTH_POLICY" ID
output "zpaPolicyTypeReauthPolicy" {
  value = data.zpa_getpolicytype.reauthPolicy.id
}

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "CLIENT_FORWARDING_POLICY" ID
const clientForwardingPolicy = zpa.getPolicyType({
    policyType: "CLIENT_FORWARDING_POLICY",
});
export const zpaPolicyTypeClientForwardingPolicy = clientForwardingPolicy.then(clientForwardingPolicy => clientForwardingPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "CLIENT_FORWARDING_POLICY" ID
client_forwarding_policy = zpa.get_policy_type(policy_type="CLIENT_FORWARDING_POLICY")
pulumi.export("zpaPolicyTypeClientForwardingPolicy", client_forwarding_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "CLIENT_FORWARDING_POLICY" ID
		clientForwardingPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("CLIENT_FORWARDING_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeClientForwardingPolicy", clientForwardingPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "CLIENT_FORWARDING_POLICY" ID
    var clientForwardingPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "CLIENT_FORWARDING_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeClientForwardingPolicy"] = clientForwardingPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "CLIENT_FORWARDING_POLICY" ID
        final var clientForwardingPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("CLIENT_FORWARDING_POLICY")
            .build());

        ctx.export("zpaPolicyTypeClientForwardingPolicy", clientForwardingPolicy.id());
    }
}

variables:
  # Get information for "CLIENT_FORWARDING_POLICY" ID
  clientForwardingPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: CLIENT_FORWARDING_POLICY
outputs:
  zpaPolicyTypeClientForwardingPolicy: ${clientForwardingPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "clientForwardingPolicy" {
  policy_type = "CLIENT_FORWARDING_POLICY"
}

# Get information for "CLIENT_FORWARDING_POLICY" ID
output "zpaPolicyTypeClientForwardingPolicy" {
  value = data.zpa_getpolicytype.clientForwardingPolicy.id
}

import * as pulumi from "@pulumi/pulumi";
import * as zpa from "@bdzscaler/pulumi-zpa";

// Get information for "INSPECTION_POLICY" ID
const inspectionPolicy = zpa.getPolicyType({
    policyType: "INSPECTION_POLICY",
});
export const zpaPolicyTypeInspectionPolicy = inspectionPolicy.then(inspectionPolicy => inspectionPolicy.id);

import pulumi
import pulumi_zpa as zpa

# Get information for "INSPECTION_POLICY" ID
inspection_policy = zpa.get_policy_type(policy_type="INSPECTION_POLICY")
pulumi.export("zpaPolicyTypeInspectionPolicy", inspection_policy.id)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// Get information for "INSPECTION_POLICY" ID
		inspectionPolicy, err := zpa.GetPolicyType(ctx, &zpa.GetPolicyTypeArgs{
			PolicyType: pulumi.StringRef("INSPECTION_POLICY"),
		}, nil)
		if err != nil {
			return err
		}
		ctx.Export("zpaPolicyTypeInspectionPolicy", inspectionPolicy.Id)
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Zpa = zscaler.PulumiPackage.Zpa;

return await Deployment.RunAsync(() => 
{
    // Get information for "INSPECTION_POLICY" ID
    var inspectionPolicy = Zpa.GetPolicyType.Invoke(new()
    {
        PolicyType = "INSPECTION_POLICY",
    });

    return new Dictionary<string, object?>
    {
        ["zpaPolicyTypeInspectionPolicy"] = inspectionPolicy.Apply(getPolicyTypeResult => getPolicyTypeResult.Id),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.zpa.ZpaFunctions;
import com.pulumi.zpa.inputs.GetPolicyTypeArgs;
import java.util.ArrayList;
import java.util.Arrays;
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) {
        // Get information for "INSPECTION_POLICY" ID
        final var inspectionPolicy = ZpaFunctions.getPolicyType(GetPolicyTypeArgs.builder()
            .policyType("INSPECTION_POLICY")
            .build());

        ctx.export("zpaPolicyTypeInspectionPolicy", inspectionPolicy.id());
    }
}

variables:
  # Get information for "INSPECTION_POLICY" ID
  inspectionPolicy:
    fn::invoke:
      function: zpa:getPolicyType
      arguments:
        policyType: INSPECTION_POLICY
outputs:
  zpaPolicyTypeInspectionPolicy: ${inspectionPolicy.id}

pulumi {
  required_providers {
    zpa = {
      source = "pulumi/zpa"
    }
  }
}

data "zpa_getpolicytype" "inspectionPolicy" {
  policy_type = "INSPECTION_POLICY"
}

# Get information for "INSPECTION_POLICY" ID
output "zpaPolicyTypeInspectionPolicy" {
  value = data.zpa_getpolicytype.inspectionPolicy.id
}

function getPolicyType(args: GetPolicyTypeArgs, opts?: InvokeOptions): Promise<GetPolicyTypeResult>
function getPolicyTypeOutput(args: GetPolicyTypeOutputArgs, opts?: InvokeOutputOptions): Output<GetPolicyTypeResult>

def get_policy_type(id: Optional[str] = None,
                    microtenant_id: Optional[str] = None,
                    microtenant_name: Optional[str] = None,
                    policy_type: Optional[str] = None,
                    opts: Optional[InvokeOptions] = None) -> GetPolicyTypeResult
def get_policy_type_output(id: pulumi.Input[Optional[str]] = None,
                    microtenant_id: pulumi.Input[Optional[str]] = None,
                    microtenant_name: pulumi.Input[Optional[str]] = None,
                    policy_type: pulumi.Input[Optional[str]] = None,
                    opts: Optional[InvokeOutputOptions] = None) -> Output[GetPolicyTypeResult]

func GetPolicyType(ctx *Context, args *GetPolicyTypeArgs, opts ...InvokeOption) (*GetPolicyTypeResult, error)
func GetPolicyTypeOutput(ctx *Context, args *GetPolicyTypeOutputArgs, opts ...InvokeOption) GetPolicyTypeResultOutput

public static class GetPolicyType 
{
    public static Task<GetPolicyTypeResult> InvokeAsync(GetPolicyTypeArgs args, InvokeOptions? opts = null)
    public static Output<GetPolicyTypeResult> Invoke(GetPolicyTypeInvokeArgs args, InvokeOptions? opts = null)
    public static Output<GetPolicyTypeResult> Invoke(GetPolicyTypeInvokeArgs args, InvokeOutputOptions opts)
}

public static CompletableFuture<GetPolicyTypeResult> getPolicyType(GetPolicyTypeArgs args, InvokeOptions options)
public static Output<GetPolicyTypeResult> getPolicyType(GetPolicyTypeArgs args, InvokeOptions options)
public static Output<GetPolicyTypeResult> getPolicyType(GetPolicyTypeArgs args, InvokeOutputOptions options)

fn::invoke:
  function: zpa:index/getPolicyType:getPolicyType
  arguments:
    # arguments dictionary

data "zpa_get_policy_type" "name" {
    # arguments
}