oci.Jms.getJavaDownloadsJavaLicense

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

const testJavaLicense = oci.Jms.getJavaDownloadsJavaLicense({
    licenseType: javaLicenseLicenseType,
});

import pulumi
import pulumi_oci as oci

test_java_license = oci.Jms.get_java_downloads_java_license(license_type=java_license_license_type)

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := Jms.GetJavaDownloadsJavaLicense(ctx, &jms.GetJavaDownloadsJavaLicenseArgs{
			LicenseType: javaLicenseLicenseType,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var testJavaLicense = Oci.Jms.GetJavaDownloadsJavaLicense.Invoke(new()
    {
        LicenseType = javaLicenseLicenseType,
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.oci.Jms.JmsFunctions;
import com.pulumi.oci.Jms.inputs.GetJavaDownloadsJavaLicenseArgs;
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 testJavaLicense = JmsFunctions.getJavaDownloadsJavaLicense(GetJavaDownloadsJavaLicenseArgs.builder()
            .licenseType(javaLicenseLicenseType)
            .build());

    }
}

variables:
  testJavaLicense:
    fn::invoke:
      Function: oci:Jms:getJavaDownloadsJavaLicense
      Arguments:
        licenseType: ${javaLicenseLicenseType}

function getJavaDownloadsJavaLicense(args: GetJavaDownloadsJavaLicenseArgs, opts?: InvokeOptions): Promise<GetJavaDownloadsJavaLicenseResult>
function getJavaDownloadsJavaLicenseOutput(args: GetJavaDownloadsJavaLicenseOutputArgs, opts?: InvokeOptions): Output<GetJavaDownloadsJavaLicenseResult>

def get_java_downloads_java_license(license_type: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetJavaDownloadsJavaLicenseResult
def get_java_downloads_java_license_output(license_type: Optional[pulumi.Input[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetJavaDownloadsJavaLicenseResult]

func GetJavaDownloadsJavaLicense(ctx *Context, args *GetJavaDownloadsJavaLicenseArgs, opts ...InvokeOption) (*GetJavaDownloadsJavaLicenseResult, error)
func GetJavaDownloadsJavaLicenseOutput(ctx *Context, args *GetJavaDownloadsJavaLicenseOutputArgs, opts ...InvokeOption) GetJavaDownloadsJavaLicenseResultOutput

public static class GetJavaDownloadsJavaLicense 
{
    public static Task<GetJavaDownloadsJavaLicenseResult> InvokeAsync(GetJavaDownloadsJavaLicenseArgs args, InvokeOptions? opts = null)
    public static Output<GetJavaDownloadsJavaLicenseResult> Invoke(GetJavaDownloadsJavaLicenseInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetJavaDownloadsJavaLicenseResult> getJavaDownloadsJavaLicense(GetJavaDownloadsJavaLicenseArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: oci:Jms/getJavaDownloadsJavaLicense:getJavaDownloadsJavaLicense
  arguments:
    # arguments dictionary