dynatrace.getDocuments

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

import pulumi

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
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) {
    }
}

{}

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

const all-dashboard-and-notebooks = dynatrace.getDocuments({});
const all-dashboards = dynatrace.getDocuments({
    type: "dashboard",
});
const all-notebooks = dynatrace.getDocuments({
    type: "notebook",
});

import pulumi
import pulumi_dynatrace as dynatrace

all_dashboard_and_notebooks = dynatrace.get_documents()
all_dashboards = dynatrace.get_documents(type="dashboard")
all_notebooks = dynatrace.get_documents(type="notebook")

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := dynatrace.GetDocuments(ctx, nil, nil)
		if err != nil {
			return err
		}
		_, err = dynatrace.GetDocuments(ctx, &dynatrace.GetDocumentsArgs{
			Type: pulumi.StringRef("dashboard"),
		}, nil)
		if err != nil {
			return err
		}
		_, err = dynatrace.GetDocuments(ctx, &dynatrace.GetDocumentsArgs{
			Type: pulumi.StringRef("notebook"),
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var all_dashboard_and_notebooks = Dynatrace.GetDocuments.Invoke();

    var all_dashboards = Dynatrace.GetDocuments.Invoke(new()
    {
        Type = "dashboard",
    });

    var all_notebooks = Dynatrace.GetDocuments.Invoke(new()
    {
        Type = "notebook",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.dynatrace.DynatraceFunctions;
import com.pulumi.dynatrace.inputs.GetDocumentsArgs;
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 all-dashboard-and-notebooks = DynatraceFunctions.getDocuments();

        final var all-dashboards = DynatraceFunctions.getDocuments(GetDocumentsArgs.builder()
            .type("dashboard")
            .build());

        final var all-notebooks = DynatraceFunctions.getDocuments(GetDocumentsArgs.builder()
            .type("notebook")
            .build());

    }
}

variables:
  all-dashboard-and-notebooks:
    fn::invoke:
      Function: dynatrace:getDocuments
      Arguments: {}
  all-dashboards:
    fn::invoke:
      Function: dynatrace:getDocuments
      Arguments:
        type: dashboard
  all-notebooks:
    fn::invoke:
      Function: dynatrace:getDocuments
      Arguments:
        type: notebook

function getDocuments(args: GetDocumentsArgs, opts?: InvokeOptions): Promise<GetDocumentsResult>
function getDocumentsOutput(args: GetDocumentsOutputArgs, opts?: InvokeOptions): Output<GetDocumentsResult>

def get_documents(type: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> GetDocumentsResult
def get_documents_output(type: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[GetDocumentsResult]

func GetDocuments(ctx *Context, args *GetDocumentsArgs, opts ...InvokeOption) (*GetDocumentsResult, error)
func GetDocumentsOutput(ctx *Context, args *GetDocumentsOutputArgs, opts ...InvokeOption) GetDocumentsResultOutput

public static class GetDocuments 
{
    public static Task<GetDocumentsResult> InvokeAsync(GetDocumentsArgs args, InvokeOptions? opts = null)
    public static Output<GetDocumentsResult> Invoke(GetDocumentsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetDocumentsResult> getDocuments(GetDocumentsArgs args, InvokeOptions options)
// Output-based functions aren't available in Java yet

fn::invoke:
  function: dynatrace:index/getDocuments:getDocuments
  arguments:
    # arguments dictionary