checkpoint.getManagementGlobalAssignment

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

const globalAssignment = new checkpoint.ManagementGlobalAssignment("globalAssignment", {
    dependentDomain: "domain2",
    globalAccessPolicy: "standard",
    globalDomain: "Global",
    globalThreatPreventionPolicy: "standard",
    manageProtectionActions: true,
});
const dataGlobalAssignment = pulumi.all([globalAssignment.dependentDomain, globalAssignment.globalDomain]).apply(([dependentDomain, globalDomain]) => checkpoint.getManagementGlobalAssignmentOutput({
    dependentDomain: dependentDomain,
    globalDomain: globalDomain,
}));

import pulumi
import pulumi_checkpoint as checkpoint

global_assignment = checkpoint.ManagementGlobalAssignment("globalAssignment",
    dependent_domain="domain2",
    global_access_policy="standard",
    global_domain="Global",
    global_threat_prevention_policy="standard",
    manage_protection_actions=True)
data_global_assignment = pulumi.Output.all(
    dependent_domain=global_assignment.dependent_domain,
    global_domain=global_assignment.global_domain
).apply(lambda resolved_outputs: checkpoint.get_management_global_assignment_output(dependent_domain=resolved_outputs['dependent_domain'],
    global_domain=resolved_outputs['global_domain']))

package main

import (
	"github.com/pulumi/pulumi-terraform-provider/sdks/go/checkpoint/v2/checkpoint"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		globalAssignment, err := checkpoint.NewManagementGlobalAssignment(ctx, "globalAssignment", &checkpoint.ManagementGlobalAssignmentArgs{
			DependentDomain:              pulumi.String("domain2"),
			GlobalAccessPolicy:           pulumi.String("standard"),
			GlobalDomain:                 pulumi.String("Global"),
			GlobalThreatPreventionPolicy: pulumi.String("standard"),
			ManageProtectionActions:      pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		_ = pulumi.All(globalAssignment.DependentDomain, globalAssignment.GlobalDomain).ApplyT(func(_args []interface{}) (checkpoint.GetManagementGlobalAssignmentResult, error) {
			dependentDomain := _args[0].(*string)
			globalDomain := _args[1].(*string)
			return checkpoint.GetManagementGlobalAssignmentResult(interface{}(checkpoint.LookupManagementGlobalAssignmentOutput(ctx, checkpoint.GetManagementGlobalAssignmentOutputArgs{
				DependentDomain: dependentDomain,
				GlobalDomain:    globalDomain,
			}, nil))), nil
		}).(checkpoint.GetManagementGlobalAssignmentResultOutput)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var globalAssignment = new Checkpoint.ManagementGlobalAssignment("globalAssignment", new()
    {
        DependentDomain = "domain2",
        GlobalAccessPolicy = "standard",
        GlobalDomain = "Global",
        GlobalThreatPreventionPolicy = "standard",
        ManageProtectionActions = true,
    });

    var dataGlobalAssignment = Checkpoint.GetManagementGlobalAssignment.Invoke(new()
    {
        DependentDomain = globalAssignment.DependentDomain,
        GlobalDomain = globalAssignment.GlobalDomain,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementGlobalAssignment;
import com.pulumi.checkpoint.ManagementGlobalAssignmentArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementGlobalAssignmentArgs;
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) {
        var globalAssignment = new ManagementGlobalAssignment("globalAssignment", ManagementGlobalAssignmentArgs.builder()
            .dependentDomain("domain2")
            .globalAccessPolicy("standard")
            .globalDomain("Global")
            .globalThreatPreventionPolicy("standard")
            .manageProtectionActions(true)
            .build());

        final var dataGlobalAssignment = CheckpointFunctions.getManagementGlobalAssignment(GetManagementGlobalAssignmentArgs.builder()
            .dependentDomain(globalAssignment.dependentDomain())
            .globalDomain(globalAssignment.globalDomain())
            .build());

    }
}

resources:
  globalAssignment:
    type: checkpoint:ManagementGlobalAssignment
    properties:
      dependentDomain: domain2
      globalAccessPolicy: standard
      globalDomain: Global
      globalThreatPreventionPolicy: standard
      manageProtectionActions: true
variables:
  dataGlobalAssignment:
    fn::invoke:
      function: checkpoint:getManagementGlobalAssignment
      arguments:
        dependentDomain: ${globalAssignment.dependentDomain}
        globalDomain: ${globalAssignment.globalDomain}

function getManagementGlobalAssignment(args: GetManagementGlobalAssignmentArgs, opts?: InvokeOptions): Promise<GetManagementGlobalAssignmentResult>
function getManagementGlobalAssignmentOutput(args: GetManagementGlobalAssignmentOutputArgs, opts?: InvokeOptions): Output<GetManagementGlobalAssignmentResult>

def get_management_global_assignment(dependent_domain: Optional[str] = None,
                                     global_domain: Optional[str] = None,
                                     id: Optional[str] = None,
                                     uid: Optional[str] = None,
                                     opts: Optional[InvokeOptions] = None) -> GetManagementGlobalAssignmentResult
def get_management_global_assignment_output(dependent_domain: Optional[pulumi.Input[str]] = None,
                                     global_domain: Optional[pulumi.Input[str]] = None,
                                     id: Optional[pulumi.Input[str]] = None,
                                     uid: Optional[pulumi.Input[str]] = None,
                                     opts: Optional[InvokeOptions] = None) -> Output[GetManagementGlobalAssignmentResult]

func LookupManagementGlobalAssignment(ctx *Context, args *LookupManagementGlobalAssignmentArgs, opts ...InvokeOption) (*LookupManagementGlobalAssignmentResult, error)
func LookupManagementGlobalAssignmentOutput(ctx *Context, args *LookupManagementGlobalAssignmentOutputArgs, opts ...InvokeOption) LookupManagementGlobalAssignmentResultOutput

public static class GetManagementGlobalAssignment 
{
    public static Task<GetManagementGlobalAssignmentResult> InvokeAsync(GetManagementGlobalAssignmentArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementGlobalAssignmentResult> Invoke(GetManagementGlobalAssignmentInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementGlobalAssignmentResult> getManagementGlobalAssignment(GetManagementGlobalAssignmentArgs args, InvokeOptions options)
public static Output<GetManagementGlobalAssignmentResult> getManagementGlobalAssignment(GetManagementGlobalAssignmentArgs args, InvokeOptions options)

fn::invoke:
  function: checkpoint:index/getManagementGlobalAssignment:getManagementGlobalAssignment
  arguments:
    # arguments dictionary