volcengine.tls.DownloadUrls

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

const foo = new volcengine.tls.DownloadTask("foo", {
    topicId: "36be6c75-0733-4bee-b63d-48e0eae37f87",
    taskName: "tf-test-download-mm",
    query: "*",
    startTime: 1740426022,
    endTime: 1740626022,
    compression: "gzip",
    dataFormat: "json",
    limit: 10000000,
    sort: "desc",
    allowIncomplete: false,
    taskType: 1,
    logContextInfos: {},
});
export const tlsDownloadTaskId = foo.taskId;
const default = volcengine.tls.getDownloadUrls({
    taskId: resource.volcengine_tls_download_task.foo.task_id,
});

import pulumi
import pulumi_volcengine as volcengine

foo = volcengine.tls.DownloadTask("foo",
    topic_id="36be6c75-0733-4bee-b63d-48e0eae37f87",
    task_name="tf-test-download-mm",
    query="*",
    start_time=1740426022,
    end_time=1740626022,
    compression="gzip",
    data_format="json",
    limit=10000000,
    sort="desc",
    allow_incomplete=False,
    task_type=1,
    log_context_infos=volcengine.tls.DownloadTaskLogContextInfosArgs())
pulumi.export("tlsDownloadTaskId", foo.task_id)
default = volcengine.tls.get_download_urls(task_id=resource["volcengine_tls_download_task"]["foo"]["task_id"])

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		foo, err := tls.NewDownloadTask(ctx, "foo", &tls.DownloadTaskArgs{
			TopicId:         pulumi.String("36be6c75-0733-4bee-b63d-48e0eae37f87"),
			TaskName:        pulumi.String("tf-test-download-mm"),
			Query:           pulumi.String("*"),
			StartTime:       pulumi.Int(1740426022),
			EndTime:         pulumi.Int(1740626022),
			Compression:     pulumi.String("gzip"),
			DataFormat:      pulumi.String("json"),
			Limit:           pulumi.Int(10000000),
			Sort:            pulumi.String("desc"),
			AllowIncomplete: pulumi.Bool(false),
			TaskType:        pulumi.Int(1),
			LogContextInfos: nil,
		})
		if err != nil {
			return err
		}
		ctx.Export("tlsDownloadTaskId", foo.TaskId)
		_, err = tls.GetDownloadUrls(ctx, &tls.GetDownloadUrlsArgs{
			TaskId: resource.Volcengine_tls_download_task.Foo.Task_id,
		}, nil)
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var foo = new Volcengine.Tls.DownloadTask("foo", new()
    {
        TopicId = "36be6c75-0733-4bee-b63d-48e0eae37f87",
        TaskName = "tf-test-download-mm",
        Query = "*",
        StartTime = 1740426022,
        EndTime = 1740626022,
        Compression = "gzip",
        DataFormat = "json",
        Limit = 10000000,
        Sort = "desc",
        AllowIncomplete = false,
        TaskType = 1,
        LogContextInfos = null,
    });

    var @default = Volcengine.Tls.GetDownloadUrls.Invoke(new()
    {
        TaskId = resource.Volcengine_tls_download_task.Foo.Task_id,
    });

    return new Dictionary<string, object?>
    {
        ["tlsDownloadTaskId"] = foo.TaskId,
    };
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.tls.DownloadTask;
import com.pulumi.volcengine.tls.DownloadTaskArgs;
import com.pulumi.volcengine.tls.inputs.DownloadTaskLogContextInfosArgs;
import com.pulumi.volcengine.tls.TlsFunctions;
import com.pulumi.volcengine.tls.inputs.GetDownloadUrlsArgs;
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 foo = new DownloadTask("foo", DownloadTaskArgs.builder()        
            .topicId("36be6c75-0733-4bee-b63d-48e0eae37f87")
            .taskName("tf-test-download-mm")
            .query("*")
            .startTime(1740426022)
            .endTime(1740626022)
            .compression("gzip")
            .dataFormat("json")
            .limit(10000000)
            .sort("desc")
            .allowIncomplete(false)
            .taskType(1)
            .logContextInfos()
            .build());

        ctx.export("tlsDownloadTaskId", foo.taskId());
        final var default = TlsFunctions.getDownloadUrls(GetDownloadUrlsArgs.builder()
            .taskId(resource.volcengine_tls_download_task().foo().task_id())
            .build());

    }
}

resources:
  foo:
    type: volcengine:tls:DownloadTask
    properties:
      topicId: 36be6c75-0733-4bee-b63d-48e0eae37f87
      taskName: tf-test-download-mm
      query: '*'
      startTime: 1.740426022e+09
      endTime: 1.740626022e+09
      compression: gzip
      dataFormat: json
      limit: 1e+07
      sort: desc
      allowIncomplete: false
      taskType: 1
      logContextInfos: {}
variables:
  default:
    fn::invoke:
      Function: volcengine:tls:getDownloadUrls
      Arguments:
        taskId: ${resource.volcengine_tls_download_task.foo.task_id}
outputs:
  tlsDownloadTaskId: ${foo.taskId}

function downloadUrls(args: DownloadUrlsArgs, opts?: InvokeOptions): Promise<DownloadUrlsResult>
function downloadUrlsOutput(args: DownloadUrlsOutputArgs, opts?: InvokeOptions): Output<DownloadUrlsResult>

def download_urls(task_id: Optional[str] = None,
                  opts: Optional[InvokeOptions] = None) -> DownloadUrlsResult
def download_urls_output(task_id: Optional[pulumi.Input[str]] = None,
                  opts: Optional[InvokeOptions] = None) -> Output[DownloadUrlsResult]

func DownloadUrls(ctx *Context, args *DownloadUrlsArgs, opts ...InvokeOption) (*DownloadUrlsResult, error)
func DownloadUrlsOutput(ctx *Context, args *DownloadUrlsOutputArgs, opts ...InvokeOption) DownloadUrlsResultOutput

public static class DownloadUrls 
{
    public static Task<DownloadUrlsResult> InvokeAsync(DownloadUrlsArgs args, InvokeOptions? opts = null)
    public static Output<DownloadUrlsResult> Invoke(DownloadUrlsInvokeArgs args, InvokeOptions? opts = null)
}

public static CompletableFuture<DownloadUrlsResult> downloadUrls(DownloadUrlsArgs args, InvokeOptions options)
public static Output<DownloadUrlsResult> downloadUrls(DownloadUrlsArgs args, InvokeOptions options)

fn::invoke:
  function: volcengine:tls:DownloadUrls
  arguments:
    # arguments dictionary