elasticstack.getKibanaAgentbuilderTool

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

const lookup = new elasticstack.KibanaAgentbuilderTool("lookup", {
    toolId: "doc-datasource-example-tool",
    type: "esql",
    description: "Example tool for datasource documentation",
    configuration: JSON.stringify({
        query: "FROM logs-* | LIMIT 1",
    }),
});
const myTool = elasticstack.getKibanaAgentbuilderToolOutput({
    id: lookup.toolId,
});
const forToolDs = new elasticstack.KibanaAgentbuilderWorkflow("for_tool_ds", {configurationYaml: `name: Workflow For Tool DS
enabled: true
triggers:
  - type: manual
inputs: []
steps:
  - name: noop
    type: console
    with:
      message: \\"workflow\\"
`});
const workflowLookup = new elasticstack.KibanaAgentbuilderTool("workflow_lookup", {
    toolId: "doc-datasource-example-workflow-tool",
    type: "workflow",
    description: "Workflow tool for datasource example",
    configuration: pulumi.jsonStringify({
        workflow_id: forToolDs.workflowId,
    }),
}, {
    dependsOn: [forToolDs],
});
const myWorkflowTool = elasticstack.getKibanaAgentbuilderToolOutput({
    id: workflowLookup.toolId,
    includeWorkflow: true,
});
export const workflowYaml = myWorkflowTool.apply(myWorkflowTool => myWorkflowTool.workflowConfigurationYaml);

import pulumi
import json
import pulumi_elasticstack as elasticstack

lookup = elasticstack.KibanaAgentbuilderTool("lookup",
    tool_id="doc-datasource-example-tool",
    type="esql",
    description="Example tool for datasource documentation",
    configuration=json.dumps({
        "query": "FROM logs-* | LIMIT 1",
    }))
my_tool = elasticstack.get_kibana_agentbuilder_tool_output(id=lookup.tool_id)
for_tool_ds = elasticstack.KibanaAgentbuilderWorkflow("for_tool_ds", configuration_yaml="""name: Workflow For Tool DS
enabled: true
triggers:
  - type: manual
inputs: []
steps:
  - name: noop
    type: console
    with:
      message: \"workflow\"
""")
workflow_lookup = elasticstack.KibanaAgentbuilderTool("workflow_lookup",
    tool_id="doc-datasource-example-workflow-tool",
    type="workflow",
    description="Workflow tool for datasource example",
    configuration=pulumi.Output.json_dumps({
        "workflow_id": for_tool_ds.workflow_id,
    }),
    opts = pulumi.ResourceOptions(depends_on=[for_tool_ds]))
my_workflow_tool = elasticstack.get_kibana_agentbuilder_tool_output(id=workflow_lookup.tool_id,
    include_workflow=True)
pulumi.export("workflowYaml", my_workflow_tool.workflow_configuration_yaml)

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-terraform-provider/sdks/go/elasticstack/elasticstack"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"query": "FROM logs-* | LIMIT 1",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		lookup, err := elasticstack.NewKibanaAgentbuilderTool(ctx, "lookup", &elasticstack.KibanaAgentbuilderToolArgs{
			ToolId:        pulumi.String("doc-datasource-example-tool"),
			Type:          pulumi.String("esql"),
			Description:   pulumi.String("Example tool for datasource documentation"),
			Configuration: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		_ = elasticstack.LookupKibanaAgentbuilderToolOutput(ctx, elasticstack.GetKibanaAgentbuilderToolOutputArgs{
			Id: lookup.ToolId,
		}, nil)
		forToolDs, err := elasticstack.NewKibanaAgentbuilderWorkflow(ctx, "for_tool_ds", &elasticstack.KibanaAgentbuilderWorkflowArgs{
			ConfigurationYaml: pulumi.String(`name: Workflow For Tool DS
enabled: true
triggers:
  - type: manual
inputs: []
steps:
  - name: noop
    type: console
    with:
      message: \"workflow\"
`),
		})
		if err != nil {
			return err
		}
		workflowLookup, err := elasticstack.NewKibanaAgentbuilderTool(ctx, "workflow_lookup", &elasticstack.KibanaAgentbuilderToolArgs{
			ToolId:      pulumi.String("doc-datasource-example-workflow-tool"),
			Type:        pulumi.String("workflow"),
			Description: pulumi.String("Workflow tool for datasource example"),
			Configuration: forToolDs.WorkflowId.ApplyT(func(workflowId string) (pulumi.String, error) {
				var _zero pulumi.String
				tmpJSON1, err := json.Marshal(map[string]interface{}{
					"workflow_id": workflowId,
				})
				if err != nil {
					return _zero, err
				}
				json1 := string(tmpJSON1)
				return pulumi.String(json1), nil
			}).(pulumi.StringOutput),
		}, pulumi.DependsOn([]pulumi.Resource{
			forToolDs,
		}))
		if err != nil {
			return err
		}
		myWorkflowTool := elasticstack.LookupKibanaAgentbuilderToolOutput(ctx, elasticstack.GetKibanaAgentbuilderToolOutputArgs{
			Id:              workflowLookup.ToolId,
			IncludeWorkflow: pulumi.Bool(true),
		}, nil)
		ctx.Export("workflowYaml", myWorkflowTool.ApplyT(func(myWorkflowTool elasticstack.GetKibanaAgentbuilderToolResult) (*string, error) {
			return &myWorkflowTool.WorkflowConfigurationYaml, nil
		}).(pulumi.StringPtrOutput))
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using System.Text.Json;
using Pulumi;
using Elasticstack = Pulumi.Elasticstack;

return await Deployment.RunAsync(() => 
{
    var lookup = new Elasticstack.KibanaAgentbuilderTool("lookup", new()
    {
        ToolId = "doc-datasource-example-tool",
        Type = "esql",
        Description = "Example tool for datasource documentation",
        Configuration = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["query"] = "FROM logs-* | LIMIT 1",
        }),
    });

    var myTool = Elasticstack.GetKibanaAgentbuilderTool.Invoke(new()
    {
        Id = lookup.ToolId,
    });

    var forToolDs = new Elasticstack.KibanaAgentbuilderWorkflow("for_tool_ds", new()
    {
        ConfigurationYaml = @"name: Workflow For Tool DS
enabled: true
triggers:
  - type: manual
inputs: []
steps:
  - name: noop
    type: console
    with:
      message: \""workflow\""
",
    });

    var workflowLookup = new Elasticstack.KibanaAgentbuilderTool("workflow_lookup", new()
    {
        ToolId = "doc-datasource-example-workflow-tool",
        Type = "workflow",
        Description = "Workflow tool for datasource example",
        Configuration = Output.JsonSerialize(Output.Create(new Dictionary<string, object?>
        {
            ["workflow_id"] = forToolDs.WorkflowId,
        })),
    }, new CustomResourceOptions
    {
        DependsOn =
        {
            forToolDs,
        },
    });

    var myWorkflowTool = Elasticstack.GetKibanaAgentbuilderTool.Invoke(new()
    {
        Id = workflowLookup.ToolId,
        IncludeWorkflow = true,
    });

    return new Dictionary<string, object?>
    {
        ["workflowYaml"] = myWorkflowTool.Apply(getKibanaAgentbuilderToolResult => getKibanaAgentbuilderToolResult.WorkflowConfigurationYaml),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.KibanaAgentbuilderTool;
import com.pulumi.elasticstack.KibanaAgentbuilderToolArgs;
import com.pulumi.elasticstack.ElasticstackFunctions;
import com.pulumi.elasticstack.inputs.GetKibanaAgentbuilderToolArgs;
import com.pulumi.elasticstack.KibanaAgentbuilderWorkflow;
import com.pulumi.elasticstack.KibanaAgentbuilderWorkflowArgs;
import static com.pulumi.codegen.internal.Serialization.*;
import com.pulumi.resources.CustomResourceOptions;
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 lookup = new KibanaAgentbuilderTool("lookup", KibanaAgentbuilderToolArgs.builder()
            .toolId("doc-datasource-example-tool")
            .type("esql")
            .description("Example tool for datasource documentation")
            .configuration(serializeJson(
                jsonObject(
                    jsonProperty("query", "FROM logs-* | LIMIT 1")
                )))
            .build());

        final var myTool = ElasticstackFunctions.getKibanaAgentbuilderTool(GetKibanaAgentbuilderToolArgs.builder()
            .id(lookup.toolId())
            .build());

        var forToolDs = new KibanaAgentbuilderWorkflow("forToolDs", KibanaAgentbuilderWorkflowArgs.builder()
            .configurationYaml("""
name: Workflow For Tool DS
enabled: true
triggers:
  - type: manual
inputs: []
steps:
  - name: noop
    type: console
    with:
      message: \"workflow\"
            """)
            .build());

        var workflowLookup = new KibanaAgentbuilderTool("workflowLookup", KibanaAgentbuilderToolArgs.builder()
            .toolId("doc-datasource-example-workflow-tool")
            .type("workflow")
            .description("Workflow tool for datasource example")
            .configuration(forToolDs.workflowId().applyValue(_workflowId -> serializeJson(
                jsonObject(
                    jsonProperty("workflow_id", _workflowId)
                ))))
            .build(), CustomResourceOptions.builder()
                .dependsOn(forToolDs)
                .build());

        final var myWorkflowTool = ElasticstackFunctions.getKibanaAgentbuilderTool(GetKibanaAgentbuilderToolArgs.builder()
            .id(workflowLookup.toolId())
            .includeWorkflow(true)
            .build());

        ctx.export("workflowYaml", myWorkflowTool.applyValue(_myWorkflowTool -> _myWorkflowTool.workflowConfigurationYaml()));
    }
}

resources:
  lookup:
    type: elasticstack:KibanaAgentbuilderTool
    properties:
      toolId: doc-datasource-example-tool
      type: esql
      description: Example tool for datasource documentation
      configuration:
        fn::toJSON:
          query: FROM logs-* | LIMIT 1
  forToolDs:
    type: elasticstack:KibanaAgentbuilderWorkflow
    name: for_tool_ds
    properties:
      configurationYaml: |
        name: Workflow For Tool DS
        enabled: true
        triggers:
          - type: manual
        inputs: []
        steps:
          - name: noop
            type: console
            with:
              message: \"workflow\"
  workflowLookup:
    type: elasticstack:KibanaAgentbuilderTool
    name: workflow_lookup
    properties:
      toolId: doc-datasource-example-workflow-tool
      type: workflow
      description: Workflow tool for datasource example
      configuration:
        fn::toJSON:
          workflow_id: ${forToolDs.workflowId}
    options:
      dependsOn:
        - ${forToolDs}
variables:
  myTool:
    fn::invoke:
      function: elasticstack:getKibanaAgentbuilderTool
      arguments:
        id: ${lookup.toolId}
  myWorkflowTool:
    fn::invoke:
      function: elasticstack:getKibanaAgentbuilderTool
      arguments:
        id: ${workflowLookup.toolId}
        includeWorkflow: true
outputs:
  workflowYaml: ${myWorkflowTool.workflowConfigurationYaml}

function getKibanaAgentbuilderTool(args: GetKibanaAgentbuilderToolArgs, opts?: InvokeOptions): Promise<GetKibanaAgentbuilderToolResult>
function getKibanaAgentbuilderToolOutput(args: GetKibanaAgentbuilderToolOutputArgs, opts?: InvokeOptions): Output<GetKibanaAgentbuilderToolResult>

def get_kibana_agentbuilder_tool(id: Optional[str] = None,
                                 include_workflow: Optional[bool] = None,
                                 kibana_connections: Optional[Sequence[GetKibanaAgentbuilderToolKibanaConnection]] = None,
                                 space_id: Optional[str] = None,
                                 opts: Optional[InvokeOptions] = None) -> GetKibanaAgentbuilderToolResult
def get_kibana_agentbuilder_tool_output(id: pulumi.Input[Optional[str]] = None,
                                 include_workflow: pulumi.Input[Optional[bool]] = None,
                                 kibana_connections: pulumi.Input[Optional[Sequence[pulumi.Input[GetKibanaAgentbuilderToolKibanaConnectionArgs]]]] = None,
                                 space_id: pulumi.Input[Optional[str]] = None,
                                 opts: Optional[InvokeOptions] = None) -> Output[GetKibanaAgentbuilderToolResult]

func LookupKibanaAgentbuilderTool(ctx *Context, args *LookupKibanaAgentbuilderToolArgs, opts ...InvokeOption) (*LookupKibanaAgentbuilderToolResult, error)
func LookupKibanaAgentbuilderToolOutput(ctx *Context, args *LookupKibanaAgentbuilderToolOutputArgs, opts ...InvokeOption) LookupKibanaAgentbuilderToolResultOutput

public static class GetKibanaAgentbuilderTool 
{
    public static Task<GetKibanaAgentbuilderToolResult> InvokeAsync(GetKibanaAgentbuilderToolArgs args, InvokeOptions? opts = null)
    public static Output<GetKibanaAgentbuilderToolResult> Invoke(GetKibanaAgentbuilderToolInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetKibanaAgentbuilderToolResult> getKibanaAgentbuilderTool(GetKibanaAgentbuilderToolArgs args, InvokeOptions options)
public static Output<GetKibanaAgentbuilderToolResult> getKibanaAgentbuilderTool(GetKibanaAgentbuilderToolArgs args, InvokeOptions options)

fn::invoke:
  function: elasticstack:index/getKibanaAgentbuilderTool:getKibanaAgentbuilderTool
  arguments:
    # arguments dictionary

data "elasticstack_getkibanaagentbuildertool" "name" {
    # arguments
}