sumologic.Content

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

return await Deployment.RunAsync(() => 
{
    var personalFolder = SumoLogic.GetPersonalFolder.Invoke();

    var test = new SumoLogic.Content("test", new()
    {
        ParentId = personalFolder.Apply(getPersonalFolderResult => getPersonalFolderResult.Id),
        Config = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["type"] = "SavedSearchWithScheduleSyncDefinition",
            ["name"] = "test-333",
            ["search"] = new Dictionary<string, object?>
            {
                ["queryText"] = "\"warn\"",
                ["defaultTimeRange"] = "-15m",
                ["byReceiptTime"] = false,
                ["viewName"] = "",
                ["viewStartTime"] = "1970-01-01T00:00:00Z",
                ["queryParameters"] = new[]
                {
                },
                ["parsingMode"] = "Manual",
            },
            ["searchSchedule"] = new Dictionary<string, object?>
            {
                ["cronExpression"] = "0 0 * * * ? *",
                ["displayableTimeRange"] = "-10m",
                ["parseableTimeRange"] = new Dictionary<string, object?>
                {
                    ["type"] = "BeginBoundedTimeRange",
                    ["from"] = new Dictionary<string, object?>
                    {
                        ["type"] = "RelativeTimeRangeBoundary",
                        ["relativeTime"] = "-50m",
                    },
                    ["to"] = null,
                },
                ["timeZone"] = "America/Los_Angeles",
                ["threshold"] = new Dictionary<string, object?>
                {
                    ["operator"] = "gt",
                    ["count"] = 0,
                },
                ["notification"] = new Dictionary<string, object?>
                {
                    ["taskType"] = "EmailSearchNotificationSyncDefinition",
                    ["toList"] = new[]
                    {
                        "ops@acme.org",
                    },
                    ["subjectTemplate"] = "Search Results: {{Name}}",
                    ["includeQuery"] = true,
                    ["includeResultSet"] = true,
                    ["includeHistogram"] = false,
                    ["includeCsvAttachment"] = false,
                },
                ["scheduleType"] = "1Hour",
                ["muteErrorEmails"] = false,
                ["parameters"] = new[]
                {
                },
            },
            ["description"] = "Runs every hour with timerange of 15m and sends email notifications",
        }),
    });

});

package main

import (
	"encoding/json"

	"github.com/pulumi/pulumi-sumologic/sdk/go/sumologic"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		personalFolder, err := sumologic.GetPersonalFolder(ctx, nil, nil)
		if err != nil {
			return err
		}
		tmpJSON0, err := json.Marshal(map[string]interface{}{
			"type": "SavedSearchWithScheduleSyncDefinition",
			"name": "test-333",
			"search": map[string]interface{}{
				"queryText":        "\"warn\"",
				"defaultTimeRange": "-15m",
				"byReceiptTime":    false,
				"viewName":         "",
				"viewStartTime":    "1970-01-01T00:00:00Z",
				"queryParameters":  []interface{}{},
				"parsingMode":      "Manual",
			},
			"searchSchedule": map[string]interface{}{
				"cronExpression":       "0 0 * * * ? *",
				"displayableTimeRange": "-10m",
				"parseableTimeRange": map[string]interface{}{
					"type": "BeginBoundedTimeRange",
					"from": map[string]interface{}{
						"type":         "RelativeTimeRangeBoundary",
						"relativeTime": "-50m",
					},
					"to": nil,
				},
				"timeZone": "America/Los_Angeles",
				"threshold": map[string]interface{}{
					"operator": "gt",
					"count":    0,
				},
				"notification": map[string]interface{}{
					"taskType": "EmailSearchNotificationSyncDefinition",
					"toList": []string{
						"ops@acme.org",
					},
					"subjectTemplate":      "Search Results: {{Name}}",
					"includeQuery":         true,
					"includeResultSet":     true,
					"includeHistogram":     false,
					"includeCsvAttachment": false,
				},
				"scheduleType":    "1Hour",
				"muteErrorEmails": false,
				"parameters":      []interface{}{},
			},
			"description": "Runs every hour with timerange of 15m and sends email notifications",
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		_, err = sumologic.NewContent(ctx, "test", &sumologic.ContentArgs{
			ParentId: *pulumi.String(personalFolder.Id),
			Config:   pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.sumologic.SumologicFunctions;
import com.pulumi.sumologic.inputs.GetPersonalFolderArgs;
import com.pulumi.sumologic.Content;
import com.pulumi.sumologic.ContentArgs;
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) {
        final var personalFolder = SumologicFunctions.getPersonalFolder();

        var test = new Content("test", ContentArgs.builder()        
            .parentId(personalFolder.applyValue(getPersonalFolderResult -> getPersonalFolderResult.id()))
            .config(serializeJson(
                jsonObject(
                    jsonProperty("type", "SavedSearchWithScheduleSyncDefinition"),
                    jsonProperty("name", "test-333"),
                    jsonProperty("search", jsonObject(
                        jsonProperty("queryText", "\"warn\""),
                        jsonProperty("defaultTimeRange", "-15m"),
                        jsonProperty("byReceiptTime", false),
                        jsonProperty("viewName", ""),
                        jsonProperty("viewStartTime", "1970-01-01T00:00:00Z"),
                        jsonProperty("queryParameters", jsonArray(
                        )),
                        jsonProperty("parsingMode", "Manual")
                    )),
                    jsonProperty("searchSchedule", jsonObject(
                        jsonProperty("cronExpression", "0 0 * * * ? *"),
                        jsonProperty("displayableTimeRange", "-10m"),
                        jsonProperty("parseableTimeRange", jsonObject(
                            jsonProperty("type", "BeginBoundedTimeRange"),
                            jsonProperty("from", jsonObject(
                                jsonProperty("type", "RelativeTimeRangeBoundary"),
                                jsonProperty("relativeTime", "-50m")
                            )),
                            jsonProperty("to", null)
                        )),
                        jsonProperty("timeZone", "America/Los_Angeles"),
                        jsonProperty("threshold", jsonObject(
                            jsonProperty("operator", "gt"),
                            jsonProperty("count", 0)
                        )),
                        jsonProperty("notification", jsonObject(
                            jsonProperty("taskType", "EmailSearchNotificationSyncDefinition"),
                            jsonProperty("toList", jsonArray("ops@acme.org")),
                            jsonProperty("subjectTemplate", "Search Results: {{Name}}"),
                            jsonProperty("includeQuery", true),
                            jsonProperty("includeResultSet", true),
                            jsonProperty("includeHistogram", false),
                            jsonProperty("includeCsvAttachment", false)
                        )),
                        jsonProperty("scheduleType", "1Hour"),
                        jsonProperty("muteErrorEmails", false),
                        jsonProperty("parameters", jsonArray(
                        ))
                    )),
                    jsonProperty("description", "Runs every hour with timerange of 15m and sends email notifications")
                )))
            .build());

    }
}

import pulumi
import json
import pulumi_sumologic as sumologic

personal_folder = sumologic.get_personal_folder()
test = sumologic.Content("test",
    parent_id=personal_folder.id,
    config=json.dumps({
        "type": "SavedSearchWithScheduleSyncDefinition",
        "name": "test-333",
        "search": {
            "queryText": "\"warn\"",
            "defaultTimeRange": "-15m",
            "byReceiptTime": False,
            "viewName": "",
            "viewStartTime": "1970-01-01T00:00:00Z",
            "queryParameters": [],
            "parsingMode": "Manual",
        },
        "searchSchedule": {
            "cronExpression": "0 0 * * * ? *",
            "displayableTimeRange": "-10m",
            "parseableTimeRange": {
                "type": "BeginBoundedTimeRange",
                "from": {
                    "type": "RelativeTimeRangeBoundary",
                    "relativeTime": "-50m",
                },
                "to": None,
            },
            "timeZone": "America/Los_Angeles",
            "threshold": {
                "operator": "gt",
                "count": 0,
            },
            "notification": {
                "taskType": "EmailSearchNotificationSyncDefinition",
                "toList": ["ops@acme.org"],
                "subjectTemplate": "Search Results: {{Name}}",
                "includeQuery": True,
                "includeResultSet": True,
                "includeHistogram": False,
                "includeCsvAttachment": False,
            },
            "scheduleType": "1Hour",
            "muteErrorEmails": False,
            "parameters": [],
        },
        "description": "Runs every hour with timerange of 15m and sends email notifications",
    }))

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

const personalFolder = sumologic.getPersonalFolder({});
const test = new sumologic.Content("test", {
    parentId: personalFolder.then(personalFolder => personalFolder.id),
    config: JSON.stringify({
        type: "SavedSearchWithScheduleSyncDefinition",
        name: "test-333",
        search: {
            queryText: "\"warn\"",
            defaultTimeRange: "-15m",
            byReceiptTime: false,
            viewName: "",
            viewStartTime: "1970-01-01T00:00:00Z",
            queryParameters: [],
            parsingMode: "Manual",
        },
        searchSchedule: {
            cronExpression: "0 0 * * * ? *",
            displayableTimeRange: "-10m",
            parseableTimeRange: {
                type: "BeginBoundedTimeRange",
                from: {
                    type: "RelativeTimeRangeBoundary",
                    relativeTime: "-50m",
                },
                to: undefined,
            },
            timeZone: "America/Los_Angeles",
            threshold: {
                operator: "gt",
                count: 0,
            },
            notification: {
                taskType: "EmailSearchNotificationSyncDefinition",
                toList: ["ops@acme.org"],
                subjectTemplate: "Search Results: {{Name}}",
                includeQuery: true,
                includeResultSet: true,
                includeHistogram: false,
                includeCsvAttachment: false,
            },
            scheduleType: "1Hour",
            muteErrorEmails: false,
            parameters: [],
        },
        description: "Runs every hour with timerange of 15m and sends email notifications",
    }),
});

resources:
  test:
    type: sumologic:Content
    properties:
      parentId: ${personalFolder.id}
      config:
        fn::toJSON:
          type: SavedSearchWithScheduleSyncDefinition
          name: test-333
          search:
            queryText: '"warn"'
            defaultTimeRange: -15m
            byReceiptTime: false
            viewName:
            viewStartTime: 1970-01-01T00:00:00Z
            queryParameters: []
            parsingMode: Manual
          searchSchedule:
            cronExpression: 0 0 * * * ? *
            displayableTimeRange: -10m
            parseableTimeRange:
              type: BeginBoundedTimeRange
              from:
                type: RelativeTimeRangeBoundary
                relativeTime: -50m
              to: null
            timeZone: America/Los_Angeles
            threshold:
              operator: gt
              count: 0
            notification:
              taskType: EmailSearchNotificationSyncDefinition
              toList:
                - ops@acme.org
              subjectTemplate: 'Search Results: {{Name}}'
              includeQuery: true
              includeResultSet: true
              includeHistogram: false
              includeCsvAttachment: false
            scheduleType: 1Hour
            muteErrorEmails: false
            parameters: []
          description: Runs every hour with timerange of 15m and sends email notifications
variables:
  personalFolder:
    fn::invoke:
      Function: sumologic:getPersonalFolder
      Arguments: {}