elasticstack.getKibanaExportSavedObjects

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

// Minimal connector so the export references a saved object that exists on first plan
// (dashboard IDs are environment-specific; action connectors created here are deterministic).
const exportDemo = new elasticstack.KibanaActionConnector("export_demo", {
    name: "examples-export-demo-connector",
    connectorTypeId: ".slack",
    secrets: JSON.stringify({
        webhookUrl: "https://example.com",
    }),
});
const example = elasticstack.getKibanaExportSavedObjectsOutput({
    spaceId: "default",
    excludeExportDetails: true,
    includeReferencesDeep: true,
    objects: [{
        type: "action",
        id: exportDemo.connectorId,
    }],
});
export const savedObjects = example.apply(example => example.exportedObjects);

import pulumi
import json
import pulumi_elasticstack as elasticstack

# Minimal connector so the export references a saved object that exists on first plan
# (dashboard IDs are environment-specific; action connectors created here are deterministic).
export_demo = elasticstack.KibanaActionConnector("export_demo",
    name="examples-export-demo-connector",
    connector_type_id=".slack",
    secrets=json.dumps({
        "webhookUrl": "https://example.com",
    }))
example = elasticstack.get_kibana_export_saved_objects_output(space_id="default",
    exclude_export_details=True,
    include_references_deep=True,
    objects=[{
        "type": "action",
        "id": export_demo.connector_id,
    }])
pulumi.export("savedObjects", example.exported_objects)

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{}{
			"webhookUrl": "https://example.com",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// Minimal connector so the export references a saved object that exists on first plan
		// (dashboard IDs are environment-specific; action connectors created here are deterministic).
		exportDemo, err := elasticstack.NewKibanaActionConnector(ctx, "export_demo", &elasticstack.KibanaActionConnectorArgs{
			Name:            pulumi.String("examples-export-demo-connector"),
			ConnectorTypeId: pulumi.String(".slack"),
			Secrets:         pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		example := elasticstack.GetKibanaExportSavedObjectsOutput(ctx, elasticstack.GetKibanaExportSavedObjectsOutputArgs{
			SpaceId:               pulumi.String("default"),
			ExcludeExportDetails:  pulumi.Bool(true),
			IncludeReferencesDeep: pulumi.Bool(true),
			Objects: elasticstack.GetKibanaExportSavedObjectsObjectArray{
				&elasticstack.GetKibanaExportSavedObjectsObjectArgs{
					Type: pulumi.String("action"),
					Id:   exportDemo.ConnectorId,
				},
			},
		}, nil)
		ctx.Export("savedObjects", example.ApplyT(func(example elasticstack.GetKibanaExportSavedObjectsResult) (*string, error) {
			return &example.ExportedObjects, 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(() => 
{
    // Minimal connector so the export references a saved object that exists on first plan
    // (dashboard IDs are environment-specific; action connectors created here are deterministic).
    var exportDemo = new Elasticstack.KibanaActionConnector("export_demo", new()
    {
        Name = "examples-export-demo-connector",
        ConnectorTypeId = ".slack",
        Secrets = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["webhookUrl"] = "https://example.com",
        }),
    });

    var example = Elasticstack.GetKibanaExportSavedObjects.Invoke(new()
    {
        SpaceId = "default",
        ExcludeExportDetails = true,
        IncludeReferencesDeep = true,
        Objects = new[]
        {
            new Elasticstack.Inputs.GetKibanaExportSavedObjectsObjectInputArgs
            {
                Type = "action",
                Id = exportDemo.ConnectorId,
            },
        },
    });

    return new Dictionary<string, object?>
    {
        ["savedObjects"] = example.Apply(getKibanaExportSavedObjectsResult => getKibanaExportSavedObjectsResult.ExportedObjects),
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.KibanaActionConnector;
import com.pulumi.elasticstack.KibanaActionConnectorArgs;
import com.pulumi.elasticstack.ElasticstackFunctions;
import com.pulumi.elasticstack.inputs.GetKibanaExportSavedObjectsArgs;
import static com.pulumi.codegen.internal.Serialization.*;
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) {
        // Minimal connector so the export references a saved object that exists on first plan
        // (dashboard IDs are environment-specific; action connectors created here are deterministic).
        var exportDemo = new KibanaActionConnector("exportDemo", KibanaActionConnectorArgs.builder()
            .name("examples-export-demo-connector")
            .connectorTypeId(".slack")
            .secrets(serializeJson(
                jsonObject(
                    jsonProperty("webhookUrl", "https://example.com")
                )))
            .build());

        final var example = ElasticstackFunctions.getKibanaExportSavedObjects(GetKibanaExportSavedObjectsArgs.builder()
            .spaceId("default")
            .excludeExportDetails(true)
            .includeReferencesDeep(true)
            .objects(GetKibanaExportSavedObjectsObjectArgs.builder()
                .type("action")
                .id(exportDemo.connectorId())
                .build())
            .build());

        ctx.export("savedObjects", example.applyValue(_example -> _example.exportedObjects()));
    }
}

resources:
  # Minimal connector so the export references a saved object that exists on first plan
  # (dashboard IDs are environment-specific; action connectors created here are deterministic).
  exportDemo:
    type: elasticstack:KibanaActionConnector
    name: export_demo
    properties:
      name: examples-export-demo-connector
      connectorTypeId: .slack
      secrets:
        fn::toJSON:
          webhookUrl: https://example.com
variables:
  example:
    fn::invoke:
      function: elasticstack:getKibanaExportSavedObjects
      arguments:
        spaceId: default
        excludeExportDetails: true
        includeReferencesDeep: true
        objects:
          - type: action
            id: ${exportDemo.connectorId}
outputs:
  savedObjects: ${example.exportedObjects}

function getKibanaExportSavedObjects(args: GetKibanaExportSavedObjectsArgs, opts?: InvokeOptions): Promise<GetKibanaExportSavedObjectsResult>
function getKibanaExportSavedObjectsOutput(args: GetKibanaExportSavedObjectsOutputArgs, opts?: InvokeOptions): Output<GetKibanaExportSavedObjectsResult>

def get_kibana_export_saved_objects(exclude_export_details: Optional[bool] = None,
                                    include_references_deep: Optional[bool] = None,
                                    kibana_connections: Optional[Sequence[GetKibanaExportSavedObjectsKibanaConnection]] = None,
                                    objects: Optional[Sequence[GetKibanaExportSavedObjectsObject]] = None,
                                    space_id: Optional[str] = None,
                                    opts: Optional[InvokeOptions] = None) -> GetKibanaExportSavedObjectsResult
def get_kibana_export_saved_objects_output(exclude_export_details: pulumi.Input[Optional[bool]] = None,
                                    include_references_deep: pulumi.Input[Optional[bool]] = None,
                                    kibana_connections: pulumi.Input[Optional[Sequence[pulumi.Input[GetKibanaExportSavedObjectsKibanaConnectionArgs]]]] = None,
                                    objects: pulumi.Input[Optional[Sequence[pulumi.Input[GetKibanaExportSavedObjectsObjectArgs]]]] = None,
                                    space_id: pulumi.Input[Optional[str]] = None,
                                    opts: Optional[InvokeOptions] = None) -> Output[GetKibanaExportSavedObjectsResult]

func GetKibanaExportSavedObjects(ctx *Context, args *GetKibanaExportSavedObjectsArgs, opts ...InvokeOption) (*GetKibanaExportSavedObjectsResult, error)
func GetKibanaExportSavedObjectsOutput(ctx *Context, args *GetKibanaExportSavedObjectsOutputArgs, opts ...InvokeOption) GetKibanaExportSavedObjectsResultOutput

public static class GetKibanaExportSavedObjects 
{
    public static Task<GetKibanaExportSavedObjectsResult> InvokeAsync(GetKibanaExportSavedObjectsArgs args, InvokeOptions? opts = null)
    public static Output<GetKibanaExportSavedObjectsResult> Invoke(GetKibanaExportSavedObjectsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<GetKibanaExportSavedObjectsResult> getKibanaExportSavedObjects(GetKibanaExportSavedObjectsArgs args, InvokeOptions options)
public static Output<GetKibanaExportSavedObjectsResult> getKibanaExportSavedObjects(GetKibanaExportSavedObjectsArgs args, InvokeOptions options)

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

data "elasticstack_getkibanaexportsavedobjects" "name" {
    # arguments
}