elasticstack.ElasticsearchMlDatafeedState

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

//# The following resources setup a realtime ML datafeed.
const mlDatafeedIndex = new elasticstack.ElasticsearchIndex("ml_datafeed_index", {
    name: "ml-datafeed-data",
    mappings: JSON.stringify({
        properties: {
            "@timestamp": {
                type: "date",
            },
            value: {
                type: "double",
            },
            user: {
                type: "keyword",
            },
        },
    }),
});
const example = new elasticstack.ElasticsearchMlAnomalyDetectionJob("example", {
    jobId: "example-anomaly-job",
    description: "Example anomaly detection job",
    analysisConfig: {
        bucketSpan: "15m",
        detectors: [{
            "function": "mean",
            fieldName: "value",
            byFieldName: "user",
        }],
    },
    dataDescription: {
        timeField: "@timestamp",
    },
});
const exampleElasticsearchMlDatafeed = new elasticstack.ElasticsearchMlDatafeed("example", {
    datafeedId: "example-datafeed",
    jobId: example.jobId,
    indices: [mlDatafeedIndex.name],
    query: JSON.stringify({
        bool: {
            must: [{
                range: {
                    "@timestamp": {
                        gte: "now-7d",
                    },
                },
            }],
        },
    }),
});
const exampleElasticsearchMlDatafeedState = new elasticstack.ElasticsearchMlDatafeedState("example", {
    datafeedId: exampleElasticsearchMlDatafeed.datafeedId,
    state: "started",
    force: false,
});
//# A non-realtime datafeed will automatically stop once all data has been processed.
//# It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
const non_realtime = new elasticstack.ElasticsearchMlAnomalyDetectionJob("non-realtime", {
    jobId: "non-realtime-anomaly-job",
    description: "Test job for datafeed state testing with time range",
    analysisConfig: {
        bucketSpan: "1h",
        detectors: [{
            "function": "count",
            detectorDescription: "count",
        }],
    },
    dataDescription: {
        timeField: "@timestamp",
        timeFormat: "epoch_ms",
    },
    analysisLimits: {
        modelMemoryLimit: "10mb",
    },
});
const non_realtimeElasticsearchMlJobState = new elasticstack.ElasticsearchMlJobState("non-realtime", {
    jobId: non_realtime.jobId,
    state: "opened",
});
const non_realtimeElasticsearchMlDatafeed = new elasticstack.ElasticsearchMlDatafeed("non-realtime", {
    datafeedId: "non-realtime-datafeed",
    jobId: non_realtime.jobId,
    indices: [mlDatafeedIndex.name],
    query: JSON.stringify({
        match_all: {},
    }),
});
const non_realtimeElasticsearchMlDatafeedState = new elasticstack.ElasticsearchMlDatafeedState("non-realtime", {
    datafeedId: non_realtimeElasticsearchMlDatafeed.datafeedId,
    state: "started",
    start: "2024-01-01T00:00:00Z",
    end: "2024-01-02T00:00:00Z",
    datafeedTimeout: "60s",
});

import pulumi
import json
import pulumi_elasticstack as elasticstack

## The following resources setup a realtime ML datafeed.
ml_datafeed_index = elasticstack.ElasticsearchIndex("ml_datafeed_index",
    name="ml-datafeed-data",
    mappings=json.dumps({
        "properties": {
            "@timestamp": {
                "type": "date",
            },
            "value": {
                "type": "double",
            },
            "user": {
                "type": "keyword",
            },
        },
    }))
example = elasticstack.ElasticsearchMlAnomalyDetectionJob("example",
    job_id="example-anomaly-job",
    description="Example anomaly detection job",
    analysis_config={
        "bucket_span": "15m",
        "detectors": [{
            "function": "mean",
            "field_name": "value",
            "by_field_name": "user",
        }],
    },
    data_description={
        "time_field": "@timestamp",
    })
example_elasticsearch_ml_datafeed = elasticstack.ElasticsearchMlDatafeed("example",
    datafeed_id="example-datafeed",
    job_id=example.job_id,
    indices=[ml_datafeed_index.name],
    query=json.dumps({
        "bool": {
            "must": [{
                "range": {
                    "@timestamp": {
                        "gte": "now-7d",
                    },
                },
            }],
        },
    }))
example_elasticsearch_ml_datafeed_state = elasticstack.ElasticsearchMlDatafeedState("example",
    datafeed_id=example_elasticsearch_ml_datafeed.datafeed_id,
    state="started",
    force=False)
## A non-realtime datafeed will automatically stop once all data has been processed.
## It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
non_realtime = elasticstack.ElasticsearchMlAnomalyDetectionJob("non-realtime",
    job_id="non-realtime-anomaly-job",
    description="Test job for datafeed state testing with time range",
    analysis_config={
        "bucket_span": "1h",
        "detectors": [{
            "function": "count",
            "detector_description": "count",
        }],
    },
    data_description={
        "time_field": "@timestamp",
        "time_format": "epoch_ms",
    },
    analysis_limits={
        "model_memory_limit": "10mb",
    })
non_realtime_elasticsearch_ml_job_state = elasticstack.ElasticsearchMlJobState("non-realtime",
    job_id=non_realtime.job_id,
    state="opened")
non_realtime_elasticsearch_ml_datafeed = elasticstack.ElasticsearchMlDatafeed("non-realtime",
    datafeed_id="non-realtime-datafeed",
    job_id=non_realtime.job_id,
    indices=[ml_datafeed_index.name],
    query=json.dumps({
        "match_all": {},
    }))
non_realtime_elasticsearch_ml_datafeed_state = elasticstack.ElasticsearchMlDatafeedState("non-realtime",
    datafeed_id=non_realtime_elasticsearch_ml_datafeed.datafeed_id,
    state="started",
    start="2024-01-01T00:00:00Z",
    end="2024-01-02T00:00:00Z",
    datafeed_timeout="60s")

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{}{
			"properties": map[string]interface{}{
				"@timestamp": map[string]interface{}{
					"type": "date",
				},
				"value": map[string]interface{}{
					"type": "double",
				},
				"user": map[string]interface{}{
					"type": "keyword",
				},
			},
		})
		if err != nil {
			return err
		}
		json0 := string(tmpJSON0)
		// # The following resources setup a realtime ML datafeed.
		mlDatafeedIndex, err := elasticstack.NewElasticsearchIndex(ctx, "ml_datafeed_index", &elasticstack.ElasticsearchIndexArgs{
			Name:     pulumi.String("ml-datafeed-data"),
			Mappings: pulumi.String(json0),
		})
		if err != nil {
			return err
		}
		example, err := elasticstack.NewElasticsearchMlAnomalyDetectionJob(ctx, "example", &elasticstack.ElasticsearchMlAnomalyDetectionJobArgs{
			JobId:       pulumi.String("example-anomaly-job"),
			Description: pulumi.String("Example anomaly detection job"),
			AnalysisConfig: &elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs{
				BucketSpan: pulumi.String("15m"),
				Detectors: elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArray{
					&elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs{
						Function:    pulumi.String("mean"),
						FieldName:   pulumi.String("value"),
						ByFieldName: pulumi.String("user"),
					},
				},
			},
			DataDescription: &elasticstack.ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs{
				TimeField: pulumi.String("@timestamp"),
			},
		})
		if err != nil {
			return err
		}
		tmpJSON1, err := json.Marshal(map[string]interface{}{
			"bool": map[string]interface{}{
				"must": []map[string]interface{}{
					map[string]interface{}{
						"range": map[string]interface{}{
							"@timestamp": map[string]interface{}{
								"gte": "now-7d",
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		json1 := string(tmpJSON1)
		exampleElasticsearchMlDatafeed, err := elasticstack.NewElasticsearchMlDatafeed(ctx, "example", &elasticstack.ElasticsearchMlDatafeedArgs{
			DatafeedId: pulumi.String("example-datafeed"),
			JobId:      example.JobId,
			Indices: pulumi.StringArray{
				mlDatafeedIndex.Name,
			},
			Query: pulumi.String(json1),
		})
		if err != nil {
			return err
		}
		_, err = elasticstack.NewElasticsearchMlDatafeedState(ctx, "example", &elasticstack.ElasticsearchMlDatafeedStateArgs{
			DatafeedId: exampleElasticsearchMlDatafeed.DatafeedId,
			State:      pulumi.String("started"),
			Force:      pulumi.Bool(false),
		})
		if err != nil {
			return err
		}
		// # A non-realtime datafeed will automatically stop once all data has been processed.
		// # It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
		non_realtime, err := elasticstack.NewElasticsearchMlAnomalyDetectionJob(ctx, "non-realtime", &elasticstack.ElasticsearchMlAnomalyDetectionJobArgs{
			JobId:       pulumi.String("non-realtime-anomaly-job"),
			Description: pulumi.String("Test job for datafeed state testing with time range"),
			AnalysisConfig: &elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs{
				BucketSpan: pulumi.String("1h"),
				Detectors: elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArray{
					&elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs{
						Function:            pulumi.String("count"),
						DetectorDescription: pulumi.String("count"),
					},
				},
			},
			DataDescription: &elasticstack.ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs{
				TimeField:  pulumi.String("@timestamp"),
				TimeFormat: pulumi.String("epoch_ms"),
			},
			AnalysisLimits: &elasticstack.ElasticsearchMlAnomalyDetectionJobAnalysisLimitsArgs{
				ModelMemoryLimit: pulumi.String("10mb"),
			},
		})
		if err != nil {
			return err
		}
		_, err = elasticstack.NewElasticsearchMlJobState(ctx, "non-realtime", &elasticstack.ElasticsearchMlJobStateArgs{
			JobId: non_realtime.JobId,
			State: pulumi.String("opened"),
		})
		if err != nil {
			return err
		}
		tmpJSON2, err := json.Marshal(map[string]interface{}{
			"match_all": map[string]interface{}{},
		})
		if err != nil {
			return err
		}
		json2 := string(tmpJSON2)
		non_realtimeElasticsearchMlDatafeed, err := elasticstack.NewElasticsearchMlDatafeed(ctx, "non-realtime", &elasticstack.ElasticsearchMlDatafeedArgs{
			DatafeedId: pulumi.String("non-realtime-datafeed"),
			JobId:      non_realtime.JobId,
			Indices: pulumi.StringArray{
				mlDatafeedIndex.Name,
			},
			Query: pulumi.String(json2),
		})
		if err != nil {
			return err
		}
		_, err = elasticstack.NewElasticsearchMlDatafeedState(ctx, "non-realtime", &elasticstack.ElasticsearchMlDatafeedStateArgs{
			DatafeedId:      non_realtimeElasticsearchMlDatafeed.DatafeedId,
			State:           pulumi.String("started"),
			Start:           pulumi.String("2024-01-01T00:00:00Z"),
			End:             pulumi.String("2024-01-02T00:00:00Z"),
			DatafeedTimeout: pulumi.String("60s"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    //# The following resources setup a realtime ML datafeed.
    var mlDatafeedIndex = new Elasticstack.ElasticsearchIndex("ml_datafeed_index", new()
    {
        Name = "ml-datafeed-data",
        Mappings = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["properties"] = new Dictionary<string, object?>
            {
                ["@timestamp"] = new Dictionary<string, object?>
                {
                    ["type"] = "date",
                },
                ["value"] = new Dictionary<string, object?>
                {
                    ["type"] = "double",
                },
                ["user"] = new Dictionary<string, object?>
                {
                    ["type"] = "keyword",
                },
            },
        }),
    });

    var example = new Elasticstack.ElasticsearchMlAnomalyDetectionJob("example", new()
    {
        JobId = "example-anomaly-job",
        Description = "Example anomaly detection job",
        AnalysisConfig = new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs
        {
            BucketSpan = "15m",
            Detectors = new[]
            {
                new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs
                {
                    Function = "mean",
                    FieldName = "value",
                    ByFieldName = "user",
                },
            },
        },
        DataDescription = new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs
        {
            TimeField = "@timestamp",
        },
    });

    var exampleElasticsearchMlDatafeed = new Elasticstack.ElasticsearchMlDatafeed("example", new()
    {
        DatafeedId = "example-datafeed",
        JobId = example.JobId,
        Indices = new[]
        {
            mlDatafeedIndex.Name,
        },
        Query = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["bool"] = new Dictionary<string, object?>
            {
                ["must"] = new[]
                {
                    new Dictionary<string, object?>
                    {
                        ["range"] = new Dictionary<string, object?>
                        {
                            ["@timestamp"] = new Dictionary<string, object?>
                            {
                                ["gte"] = "now-7d",
                            },
                        },
                    },
                },
            },
        }),
    });

    var exampleElasticsearchMlDatafeedState = new Elasticstack.ElasticsearchMlDatafeedState("example", new()
    {
        DatafeedId = exampleElasticsearchMlDatafeed.DatafeedId,
        State = "started",
        Force = false,
    });

    //# A non-realtime datafeed will automatically stop once all data has been processed.
    //# It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
    var non_realtime = new Elasticstack.ElasticsearchMlAnomalyDetectionJob("non-realtime", new()
    {
        JobId = "non-realtime-anomaly-job",
        Description = "Test job for datafeed state testing with time range",
        AnalysisConfig = new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs
        {
            BucketSpan = "1h",
            Detectors = new[]
            {
                new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs
                {
                    Function = "count",
                    DetectorDescription = "count",
                },
            },
        },
        DataDescription = new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs
        {
            TimeField = "@timestamp",
            TimeFormat = "epoch_ms",
        },
        AnalysisLimits = new Elasticstack.Inputs.ElasticsearchMlAnomalyDetectionJobAnalysisLimitsArgs
        {
            ModelMemoryLimit = "10mb",
        },
    });

    var non_realtimeElasticsearchMlJobState = new Elasticstack.ElasticsearchMlJobState("non-realtime", new()
    {
        JobId = non_realtime.JobId,
        State = "opened",
    });

    var non_realtimeElasticsearchMlDatafeed = new Elasticstack.ElasticsearchMlDatafeed("non-realtime", new()
    {
        DatafeedId = "non-realtime-datafeed",
        JobId = non_realtime.JobId,
        Indices = new[]
        {
            mlDatafeedIndex.Name,
        },
        Query = JsonSerializer.Serialize(new Dictionary<string, object?>
        {
            ["match_all"] = new Dictionary<string, object?>
            {
            },
        }),
    });

    var non_realtimeElasticsearchMlDatafeedState = new Elasticstack.ElasticsearchMlDatafeedState("non-realtime", new()
    {
        DatafeedId = non_realtimeElasticsearchMlDatafeed.DatafeedId,
        State = "started",
        Start = "2024-01-01T00:00:00Z",
        End = "2024-01-02T00:00:00Z",
        DatafeedTimeout = "60s",
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.elasticstack.ElasticsearchIndex;
import com.pulumi.elasticstack.ElasticsearchIndexArgs;
import com.pulumi.elasticstack.ElasticsearchMlAnomalyDetectionJob;
import com.pulumi.elasticstack.ElasticsearchMlAnomalyDetectionJobArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs;
import com.pulumi.elasticstack.ElasticsearchMlDatafeed;
import com.pulumi.elasticstack.ElasticsearchMlDatafeedArgs;
import com.pulumi.elasticstack.ElasticsearchMlDatafeedState;
import com.pulumi.elasticstack.ElasticsearchMlDatafeedStateArgs;
import com.pulumi.elasticstack.inputs.ElasticsearchMlAnomalyDetectionJobAnalysisLimitsArgs;
import com.pulumi.elasticstack.ElasticsearchMlJobState;
import com.pulumi.elasticstack.ElasticsearchMlJobStateArgs;
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) {
        //# The following resources setup a realtime ML datafeed.
        var mlDatafeedIndex = new ElasticsearchIndex("mlDatafeedIndex", ElasticsearchIndexArgs.builder()
            .name("ml-datafeed-data")
            .mappings(serializeJson(
                jsonObject(
                    jsonProperty("properties", jsonObject(
                        jsonProperty("@timestamp", jsonObject(
                            jsonProperty("type", "date")
                        )),
                        jsonProperty("value", jsonObject(
                            jsonProperty("type", "double")
                        )),
                        jsonProperty("user", jsonObject(
                            jsonProperty("type", "keyword")
                        ))
                    ))
                )))
            .build());

        var example = new ElasticsearchMlAnomalyDetectionJob("example", ElasticsearchMlAnomalyDetectionJobArgs.builder()
            .jobId("example-anomaly-job")
            .description("Example anomaly detection job")
            .analysisConfig(ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs.builder()
                .bucketSpan("15m")
                .detectors(ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs.builder()
                    .function("mean")
                    .fieldName("value")
                    .byFieldName("user")
                    .build())
                .build())
            .dataDescription(ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs.builder()
                .timeField("@timestamp")
                .build())
            .build());

        var exampleElasticsearchMlDatafeed = new ElasticsearchMlDatafeed("exampleElasticsearchMlDatafeed", ElasticsearchMlDatafeedArgs.builder()
            .datafeedId("example-datafeed")
            .jobId(example.jobId())
            .indices(mlDatafeedIndex.name())
            .query(serializeJson(
                jsonObject(
                    jsonProperty("bool", jsonObject(
                        jsonProperty("must", jsonArray(jsonObject(
                            jsonProperty("range", jsonObject(
                                jsonProperty("@timestamp", jsonObject(
                                    jsonProperty("gte", "now-7d")
                                ))
                            ))
                        )))
                    ))
                )))
            .build());

        var exampleElasticsearchMlDatafeedState = new ElasticsearchMlDatafeedState("exampleElasticsearchMlDatafeedState", ElasticsearchMlDatafeedStateArgs.builder()
            .datafeedId(exampleElasticsearchMlDatafeed.datafeedId())
            .state("started")
            .force(false)
            .build());

        //# A non-realtime datafeed will automatically stop once all data has been processed.
        //# It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
        var non_realtime = new ElasticsearchMlAnomalyDetectionJob("non-realtime", ElasticsearchMlAnomalyDetectionJobArgs.builder()
            .jobId("non-realtime-anomaly-job")
            .description("Test job for datafeed state testing with time range")
            .analysisConfig(ElasticsearchMlAnomalyDetectionJobAnalysisConfigArgs.builder()
                .bucketSpan("1h")
                .detectors(ElasticsearchMlAnomalyDetectionJobAnalysisConfigDetectorArgs.builder()
                    .function("count")
                    .detectorDescription("count")
                    .build())
                .build())
            .dataDescription(ElasticsearchMlAnomalyDetectionJobDataDescriptionArgs.builder()
                .timeField("@timestamp")
                .timeFormat("epoch_ms")
                .build())
            .analysisLimits(ElasticsearchMlAnomalyDetectionJobAnalysisLimitsArgs.builder()
                .modelMemoryLimit("10mb")
                .build())
            .build());

        var non_realtimeElasticsearchMlJobState = new ElasticsearchMlJobState("non-realtimeElasticsearchMlJobState", ElasticsearchMlJobStateArgs.builder()
            .jobId(non_realtime.jobId())
            .state("opened")
            .build());

        var non_realtimeElasticsearchMlDatafeed = new ElasticsearchMlDatafeed("non-realtimeElasticsearchMlDatafeed", ElasticsearchMlDatafeedArgs.builder()
            .datafeedId("non-realtime-datafeed")
            .jobId(non_realtime.jobId())
            .indices(mlDatafeedIndex.name())
            .query(serializeJson(
                jsonObject(
                    jsonProperty("match_all", jsonObject(

                    ))
                )))
            .build());

        var non_realtimeElasticsearchMlDatafeedState = new ElasticsearchMlDatafeedState("non-realtimeElasticsearchMlDatafeedState", ElasticsearchMlDatafeedStateArgs.builder()
            .datafeedId(non_realtimeElasticsearchMlDatafeed.datafeedId())
            .state("started")
            .start("2024-01-01T00:00:00Z")
            .end("2024-01-02T00:00:00Z")
            .datafeedTimeout("60s")
            .build());

    }
}

resources:
  ## The following resources setup a realtime ML datafeed.
  mlDatafeedIndex:
    type: elasticstack:ElasticsearchIndex
    name: ml_datafeed_index
    properties:
      name: ml-datafeed-data
      mappings:
        fn::toJSON:
          properties:
            '@timestamp':
              type: date
            value:
              type: double
            user:
              type: keyword
  example:
    type: elasticstack:ElasticsearchMlAnomalyDetectionJob
    properties:
      jobId: example-anomaly-job
      description: Example anomaly detection job
      analysisConfig:
        bucketSpan: 15m
        detectors:
          - function: mean
            fieldName: value
            byFieldName: user
      dataDescription:
        timeField: '@timestamp'
  exampleElasticsearchMlDatafeed:
    type: elasticstack:ElasticsearchMlDatafeed
    name: example
    properties:
      datafeedId: example-datafeed
      jobId: ${example.jobId}
      indices:
        - ${mlDatafeedIndex.name}
      query:
        fn::toJSON:
          bool:
            must:
              - range:
                  '@timestamp':
                    gte: now-7d
  exampleElasticsearchMlDatafeedState:
    type: elasticstack:ElasticsearchMlDatafeedState
    name: example
    properties:
      datafeedId: ${exampleElasticsearchMlDatafeed.datafeedId}
      state: started
      force: false
  ## A non-realtime datafeed will automatically stop once all data has been processed.
  ## It's recommended to ignore changes to the `state` attribute via the resource lifecycle for such datafeeds.
  non-realtime:
    type: elasticstack:ElasticsearchMlAnomalyDetectionJob
    properties:
      jobId: non-realtime-anomaly-job
      description: Test job for datafeed state testing with time range
      analysisConfig:
        bucketSpan: 1h
        detectors:
          - function: count
            detectorDescription: count
      dataDescription:
        timeField: '@timestamp'
        timeFormat: epoch_ms
      analysisLimits:
        modelMemoryLimit: 10mb
  non-realtimeElasticsearchMlJobState:
    type: elasticstack:ElasticsearchMlJobState
    name: non-realtime
    properties:
      jobId: ${["non-realtime"].jobId}
      state: opened
  non-realtimeElasticsearchMlDatafeed:
    type: elasticstack:ElasticsearchMlDatafeed
    name: non-realtime
    properties:
      datafeedId: non-realtime-datafeed
      jobId: ${["non-realtime"].jobId}
      indices:
        - ${mlDatafeedIndex.name}
      query:
        fn::toJSON:
          match_all: {}
  non-realtimeElasticsearchMlDatafeedState:
    type: elasticstack:ElasticsearchMlDatafeedState
    name: non-realtime
    properties:
      datafeedId: ${["non-realtimeElasticsearchMlDatafeed"].datafeedId}
      state: started
      start: 2024-01-01T00:00:00Z
      end: 2024-01-02T00:00:00Z
      datafeedTimeout: 60s

var elasticsearchMlDatafeedStateResource = new Elasticstack.ElasticsearchMlDatafeedState("elasticsearchMlDatafeedStateResource", new()
{
    DatafeedId = "string",
    State = "string",
    DatafeedTimeout = "string",
    End = "string",
    Force = false,
    Start = "string",
    Timeouts = new Elasticstack.Inputs.ElasticsearchMlDatafeedStateTimeoutsArgs
    {
        Create = "string",
        Update = "string",
    },
});

example, err := elasticstack.NewElasticsearchMlDatafeedState(ctx, "elasticsearchMlDatafeedStateResource", &elasticstack.ElasticsearchMlDatafeedStateArgs{
	DatafeedId:      pulumi.String("string"),
	State:           pulumi.String("string"),
	DatafeedTimeout: pulumi.String("string"),
	End:             pulumi.String("string"),
	Force:           pulumi.Bool(false),
	Start:           pulumi.String("string"),
	Timeouts: &elasticstack.ElasticsearchMlDatafeedStateTimeoutsArgs{
		Create: pulumi.String("string"),
		Update: pulumi.String("string"),
	},
})

var elasticsearchMlDatafeedStateResource = new ElasticsearchMlDatafeedState("elasticsearchMlDatafeedStateResource", ElasticsearchMlDatafeedStateArgs.builder()
    .datafeedId("string")
    .state("string")
    .datafeedTimeout("string")
    .end("string")
    .force(false)
    .start("string")
    .timeouts(ElasticsearchMlDatafeedStateTimeoutsArgs.builder()
        .create("string")
        .update("string")
        .build())
    .build());

elasticsearch_ml_datafeed_state_resource = elasticstack.ElasticsearchMlDatafeedState("elasticsearchMlDatafeedStateResource",
    datafeed_id="string",
    state="string",
    datafeed_timeout="string",
    end="string",
    force=False,
    start="string",
    timeouts={
        "create": "string",
        "update": "string",
    })

const elasticsearchMlDatafeedStateResource = new elasticstack.ElasticsearchMlDatafeedState("elasticsearchMlDatafeedStateResource", {
    datafeedId: "string",
    state: "string",
    datafeedTimeout: "string",
    end: "string",
    force: false,
    start: "string",
    timeouts: {
        create: "string",
        update: "string",
    },
});

type: elasticstack:ElasticsearchMlDatafeedState
properties:
    datafeedId: string
    datafeedTimeout: string
    end: string
    force: false
    start: string
    state: string
    timeouts:
        create: string
        update: string