checkpoint.getManagementOutboundInspectionCertificate

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

const example = new checkpoint.ManagementOutboundInspectionCertificate("example", {
    base64Password: "bXlfcGFzc3dvcmQ=",
    issuedBy: "www.checkpoint.com",
    validFrom: "2021-04-17",
    validTo: "2028-04-17",
});
const data = checkpoint.getManagementOutboundInspectionCertificateOutput({
    uid: example.managementOutboundInspectionCertificateId,
});

import pulumi
import pulumi_checkpoint as checkpoint

example = checkpoint.ManagementOutboundInspectionCertificate("example",
    base64_password="bXlfcGFzc3dvcmQ=",
    issued_by="www.checkpoint.com",
    valid_from="2021-04-17",
    valid_to="2028-04-17")
data = checkpoint.get_management_outbound_inspection_certificate_output(uid=example.management_outbound_inspection_certificate_id)

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 {
		example, err := checkpoint.NewManagementOutboundInspectionCertificate(ctx, "example", &checkpoint.ManagementOutboundInspectionCertificateArgs{
			Base64Password: pulumi.String("bXlfcGFzc3dvcmQ="),
			IssuedBy:       pulumi.String("www.checkpoint.com"),
			ValidFrom:      pulumi.String("2021-04-17"),
			ValidTo:        pulumi.String("2028-04-17"),
		})
		if err != nil {
			return err
		}
		_ = checkpoint.LookupManagementOutboundInspectionCertificateOutput(ctx, checkpoint.GetManagementOutboundInspectionCertificateOutputArgs{
			Uid: example.ManagementOutboundInspectionCertificateId,
		}, nil)
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var example = new Checkpoint.ManagementOutboundInspectionCertificate("example", new()
    {
        Base64Password = "bXlfcGFzc3dvcmQ=",
        IssuedBy = "www.checkpoint.com",
        ValidFrom = "2021-04-17",
        ValidTo = "2028-04-17",
    });

    var data = Checkpoint.GetManagementOutboundInspectionCertificate.Invoke(new()
    {
        Uid = example.ManagementOutboundInspectionCertificateId,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkpoint.ManagementOutboundInspectionCertificate;
import com.pulumi.checkpoint.ManagementOutboundInspectionCertificateArgs;
import com.pulumi.checkpoint.CheckpointFunctions;
import com.pulumi.checkpoint.inputs.GetManagementOutboundInspectionCertificateArgs;
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 example = new ManagementOutboundInspectionCertificate("example", ManagementOutboundInspectionCertificateArgs.builder()
            .base64Password("bXlfcGFzc3dvcmQ=")
            .issuedBy("www.checkpoint.com")
            .validFrom("2021-04-17")
            .validTo("2028-04-17")
            .build());

        final var data = CheckpointFunctions.getManagementOutboundInspectionCertificate(GetManagementOutboundInspectionCertificateArgs.builder()
            .uid(example.managementOutboundInspectionCertificateId())
            .build());

    }
}

resources:
  example:
    type: checkpoint:ManagementOutboundInspectionCertificate
    properties:
      base64Password: bXlfcGFzc3dvcmQ=
      issuedBy: www.checkpoint.com
      validFrom: 2021-04-17
      validTo: 2028-04-17
variables:
  data:
    fn::invoke:
      function: checkpoint:getManagementOutboundInspectionCertificate
      arguments:
        uid: ${example.managementOutboundInspectionCertificateId}

function getManagementOutboundInspectionCertificate(args: GetManagementOutboundInspectionCertificateArgs, opts?: InvokeOptions): Promise<GetManagementOutboundInspectionCertificateResult>
function getManagementOutboundInspectionCertificateOutput(args: GetManagementOutboundInspectionCertificateOutputArgs, opts?: InvokeOptions): Output<GetManagementOutboundInspectionCertificateResult>

def get_management_outbound_inspection_certificate(id: Optional[str] = None,
                                                   name: Optional[str] = None,
                                                   uid: Optional[str] = None,
                                                   opts: Optional[InvokeOptions] = None) -> GetManagementOutboundInspectionCertificateResult
def get_management_outbound_inspection_certificate_output(id: Optional[pulumi.Input[str]] = None,
                                                   name: Optional[pulumi.Input[str]] = None,
                                                   uid: Optional[pulumi.Input[str]] = None,
                                                   opts: Optional[InvokeOptions] = None) -> Output[GetManagementOutboundInspectionCertificateResult]

func LookupManagementOutboundInspectionCertificate(ctx *Context, args *LookupManagementOutboundInspectionCertificateArgs, opts ...InvokeOption) (*LookupManagementOutboundInspectionCertificateResult, error)
func LookupManagementOutboundInspectionCertificateOutput(ctx *Context, args *LookupManagementOutboundInspectionCertificateOutputArgs, opts ...InvokeOption) LookupManagementOutboundInspectionCertificateResultOutput

public static class GetManagementOutboundInspectionCertificate 
{
    public static Task<GetManagementOutboundInspectionCertificateResult> InvokeAsync(GetManagementOutboundInspectionCertificateArgs args, InvokeOptions? opts = null)
    public static Output<GetManagementOutboundInspectionCertificateResult> Invoke(GetManagementOutboundInspectionCertificateInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetManagementOutboundInspectionCertificateResult> getManagementOutboundInspectionCertificate(GetManagementOutboundInspectionCertificateArgs args, InvokeOptions options)
public static Output<GetManagementOutboundInspectionCertificateResult> getManagementOutboundInspectionCertificate(GetManagementOutboundInspectionCertificateArgs args, InvokeOptions options)

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