1. Packages
  2. Datadog
  3. API Docs
  4. SyntheticsTest
Datadog v4.28.0 published on Tuesday, Apr 23, 2024 by Pulumi

datadog.SyntheticsTest

Explore with Pulumi AI

datadog logo
Datadog v4.28.0 published on Tuesday, Apr 23, 2024 by Pulumi

    Provides a Datadog synthetics test resource. This can be used to create and manage Datadog synthetics test.

    Warning

    Starting from version 3.1.0+, the direct usage of global variables in the configuration is deprecated, in favor of local variables of type global. As an example, if you were previously using {{ GLOBAL_VAR }} directly in your configuration, add a config_variable of type global with the id matching the id of the global variable GLOBAL_VAR, which can be found in the Synthetics UI or from the output of the datadog.SyntheticsGlobalVariable resource. The name can be chosen freely.

    In practice, it means going from (simplified configuration):

    url = https://{{ GLOBAL_VAR }}
    

    to

    config_variable {
      name = "LOCAL_VAR"
      id = [your_global_variable_id]
      type = "global"
    }
    

    which you can now use in your request definition:

    url = https://{{ LOCAL_VAR }}
    

    Example Usage

    import * as pulumi from "@pulumi/pulumi";
    import * as datadog from "@pulumi/datadog";
    
    // Example Usage (Synthetics API test)
    // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    const testUptime = new datadog.SyntheticsTest("test_uptime", {
        name: "An Uptime test on example.org",
        type: "api",
        subtype: "http",
        status: "live",
        message: "Notify @pagerduty",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        requestDefinition: {
            method: "GET",
            url: "https://www.example.org",
        },
        requestHeaders: {
            "Content-Type": "application/json",
        },
        assertions: [{
            type: "statusCode",
            operator: "is",
            target: "200",
        }],
        optionsList: {
            tickEvery: 900,
            retry: {
                count: 2,
                interval: 300,
            },
            monitorOptions: {
                renotifyInterval: 120,
            },
        },
    });
    // Example Usage (Authenticated API test)
    // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    const testApi = new datadog.SyntheticsTest("test_api", {
        name: "An API test on example.org",
        type: "api",
        subtype: "http",
        status: "live",
        message: "Notify @pagerduty",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        requestDefinition: {
            method: "GET",
            url: "https://www.example.org",
        },
        requestHeaders: {
            "Content-Type": "application/json",
            Authentication: "Token: 1234566789",
        },
        assertions: [{
            type: "statusCode",
            operator: "is",
            target: "200",
        }],
        optionsList: {
            tickEvery: 900,
            retry: {
                count: 2,
                interval: 300,
            },
            monitorOptions: {
                renotifyInterval: 120,
            },
        },
    });
    // Example Usage (Synthetics SSL test)
    // Create a new Datadog Synthetics API/SSL test on example.org
    const testSsl = new datadog.SyntheticsTest("test_ssl", {
        name: "An API test on example.org",
        type: "api",
        subtype: "ssl",
        status: "live",
        message: "Notify @pagerduty",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        requestDefinition: {
            host: "example.org",
            port: 443,
        },
        assertions: [{
            type: "certificate",
            operator: "isInMoreThan",
            target: "30",
        }],
        optionsList: {
            tickEvery: 900,
            acceptSelfSigned: true,
        },
    });
    // Example Usage (Synthetics TCP test)
    // Create a new Datadog Synthetics API/TCP test on example.org
    const testTcp = new datadog.SyntheticsTest("test_tcp", {
        name: "An API test on example.org",
        type: "api",
        subtype: "tcp",
        status: "live",
        message: "Notify @pagerduty",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        requestDefinition: {
            host: "example.org",
            port: 443,
        },
        assertions: [{
            type: "responseTime",
            operator: "lessThan",
            target: "2000",
        }],
        configVariables: [{
            type: "global",
            name: "MY_GLOBAL_VAR",
            id: "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
        }],
        optionsList: {
            tickEvery: 900,
        },
    });
    // Example Usage (Synthetics DNS test)
    // Create a new Datadog Synthetics API/DNS test on example.org
    const testDns = new datadog.SyntheticsTest("test_dns", {
        name: "An API test on example.org",
        type: "api",
        subtype: "dns",
        status: "live",
        message: "Notify @pagerduty",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        requestDefinition: {
            host: "example.org",
        },
        assertions: [{
            type: "recordSome",
            operator: "is",
            property: "A",
            target: "0.0.0.0",
        }],
        optionsList: {
            tickEvery: 900,
        },
    });
    // Example Usage (Synthetics Multistep API test)
    // Create a new Datadog Synthetics Multistep API test
    const testMultiStep = new datadog.SyntheticsTest("test_multi_step", {
        name: "Multistep API test",
        type: "api",
        subtype: "multi",
        status: "live",
        locations: ["aws:eu-central-1"],
        tags: [
            "foo:bar",
            "foo",
            "env:test",
        ],
        apiSteps: [
            {
                name: "An API test on example.org",
                subtype: "http",
                assertions: [{
                    type: "statusCode",
                    operator: "is",
                    target: "200",
                }],
                requestDefinition: {
                    method: "GET",
                    url: "https://example.org",
                },
                requestHeaders: {
                    "Content-Type": "application/json",
                    Authentication: "Token: 1234566789",
                },
            },
            {
                name: "An API test on example.org",
                subtype: "http",
                assertions: [{
                    type: "statusCode",
                    operator: "is",
                    target: "200",
                }],
                requestDefinition: {
                    method: "GET",
                    url: "http://example.org",
                },
            },
        ],
        optionsList: {
            tickEvery: 900,
            acceptSelfSigned: true,
        },
    });
    // Example Usage (Synthetics Browser test)
    // Create a new Datadog Synthetics Browser test starting on https://www.example.org
    const testBrowser = new datadog.SyntheticsTest("test_browser", {
        name: "A Browser test on example.org",
        type: "browser",
        status: "paused",
        message: "Notify @qa",
        deviceIds: ["laptop_large"],
        locations: ["aws:eu-central-1"],
        tags: [],
        requestDefinition: {
            method: "GET",
            url: "https://app.datadoghq.com",
        },
        browserSteps: [
            {
                name: "Check current url",
                type: "assertCurrentUrl",
                params: {
                    check: "contains",
                    value: "datadoghq",
                },
            },
            {
                name: "Test a downloaded file",
                type: "assertFileDownload",
                params: {
                    file: JSON.stringify({
                        md5: "abcdef1234567890",
                        sizeCheck: {
                            type: "equals",
                            value: 1,
                        },
                        nameCheck: {
                            type: "contains",
                            value: ".xls",
                        },
                    }),
                },
            },
        ],
        browserVariables: [
            {
                type: "text",
                name: "MY_PATTERN_VAR",
                pattern: "{{numeric(3)}}",
                example: "597",
            },
            {
                type: "email",
                name: "MY_EMAIL_VAR",
                pattern: "jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co",
                example: "jd8-afe-ydv.4546132139@synthetics.dtdg.co",
            },
            {
                type: "global",
                name: "MY_GLOBAL_VAR",
                id: "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
            },
        ],
        optionsList: {
            tickEvery: 3600,
        },
    });
    // Example Usage (GRPC API test)
    // Create a new Datadog GRPC API test starting on google.org:50050
    const grpc = new datadog.SyntheticsTest("grpc", {
        type: "api",
        subtype: "grpc",
        requestDefinition: {
            method: "GET",
            host: "google.com",
            port: 50050,
            service: "Hello",
            plainProtoFile: `syntax = "proto3";
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.helloworld";
    option java_outer_classname = "HelloWorldProto";
    option objc_class_prefix = "HLW";
    package helloworld;
    // The greeting service definition.
    service Greeter {
    \x09// Sends a greeting
    \x09rpc SayHello (HelloRequest) returns (HelloReply) {}
    }
    // The request message containing the user's name.
    message HelloRequest {
    \x09string name = 1;
    }
    // The response message containing the greetings
    message HelloReply {
    \x09string message = 1;
    }
    `,
        },
        requestMetadata: {
            header: "value",
        },
        assertions: [
            {
                type: "responseTime",
                operator: "lessThan",
                target: "2000",
            },
            {
                operator: "is",
                type: "grpcHealthcheckStatus",
                target: "1",
            },
            {
                operator: "is",
                target: "proto target",
                type: "grpcProto",
            },
            {
                operator: "is",
                target: "123",
                property: "property",
                type: "grpcMetadata",
            },
        ],
        locations: ["aws:eu-central-1"],
        optionsList: {
            tickEvery: 60,
        },
        name: "GRPC API test",
        message: "Notify @datadog.user",
        tags: [
            "foo:bar",
            "baz",
        ],
        status: "paused",
    });
    
    import pulumi
    import json
    import pulumi_datadog as datadog
    
    # Example Usage (Synthetics API test)
    # Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    test_uptime = datadog.SyntheticsTest("test_uptime",
        name="An Uptime test on example.org",
        type="api",
        subtype="http",
        status="live",
        message="Notify @pagerduty",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            method="GET",
            url="https://www.example.org",
        ),
        request_headers={
            "Content-Type": "application/json",
        },
        assertions=[datadog.SyntheticsTestAssertionArgs(
            type="statusCode",
            operator="is",
            target="200",
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
            retry=datadog.SyntheticsTestOptionsListRetryArgs(
                count=2,
                interval=300,
            ),
            monitor_options=datadog.SyntheticsTestOptionsListMonitorOptionsArgs(
                renotify_interval=120,
            ),
        ))
    # Example Usage (Authenticated API test)
    # Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    test_api = datadog.SyntheticsTest("test_api",
        name="An API test on example.org",
        type="api",
        subtype="http",
        status="live",
        message="Notify @pagerduty",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            method="GET",
            url="https://www.example.org",
        ),
        request_headers={
            "Content-Type": "application/json",
            "Authentication": "Token: 1234566789",
        },
        assertions=[datadog.SyntheticsTestAssertionArgs(
            type="statusCode",
            operator="is",
            target="200",
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
            retry=datadog.SyntheticsTestOptionsListRetryArgs(
                count=2,
                interval=300,
            ),
            monitor_options=datadog.SyntheticsTestOptionsListMonitorOptionsArgs(
                renotify_interval=120,
            ),
        ))
    # Example Usage (Synthetics SSL test)
    # Create a new Datadog Synthetics API/SSL test on example.org
    test_ssl = datadog.SyntheticsTest("test_ssl",
        name="An API test on example.org",
        type="api",
        subtype="ssl",
        status="live",
        message="Notify @pagerduty",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            host="example.org",
            port=443,
        ),
        assertions=[datadog.SyntheticsTestAssertionArgs(
            type="certificate",
            operator="isInMoreThan",
            target="30",
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
            accept_self_signed=True,
        ))
    # Example Usage (Synthetics TCP test)
    # Create a new Datadog Synthetics API/TCP test on example.org
    test_tcp = datadog.SyntheticsTest("test_tcp",
        name="An API test on example.org",
        type="api",
        subtype="tcp",
        status="live",
        message="Notify @pagerduty",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            host="example.org",
            port=443,
        ),
        assertions=[datadog.SyntheticsTestAssertionArgs(
            type="responseTime",
            operator="lessThan",
            target="2000",
        )],
        config_variables=[datadog.SyntheticsTestConfigVariableArgs(
            type="global",
            name="MY_GLOBAL_VAR",
            id="76636cd1-82e2-4aeb-9cfe-51366a8198a2",
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
        ))
    # Example Usage (Synthetics DNS test)
    # Create a new Datadog Synthetics API/DNS test on example.org
    test_dns = datadog.SyntheticsTest("test_dns",
        name="An API test on example.org",
        type="api",
        subtype="dns",
        status="live",
        message="Notify @pagerduty",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            host="example.org",
        ),
        assertions=[datadog.SyntheticsTestAssertionArgs(
            type="recordSome",
            operator="is",
            property="A",
            target="0.0.0.0",
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
        ))
    # Example Usage (Synthetics Multistep API test)
    # Create a new Datadog Synthetics Multistep API test
    test_multi_step = datadog.SyntheticsTest("test_multi_step",
        name="Multistep API test",
        type="api",
        subtype="multi",
        status="live",
        locations=["aws:eu-central-1"],
        tags=[
            "foo:bar",
            "foo",
            "env:test",
        ],
        api_steps=[
            datadog.SyntheticsTestApiStepArgs(
                name="An API test on example.org",
                subtype="http",
                assertions=[datadog.SyntheticsTestApiStepAssertionArgs(
                    type="statusCode",
                    operator="is",
                    target="200",
                )],
                request_definition=datadog.SyntheticsTestApiStepRequestDefinitionArgs(
                    method="GET",
                    url="https://example.org",
                ),
                request_headers={
                    "Content-Type": "application/json",
                    "Authentication": "Token: 1234566789",
                },
            ),
            datadog.SyntheticsTestApiStepArgs(
                name="An API test on example.org",
                subtype="http",
                assertions=[datadog.SyntheticsTestApiStepAssertionArgs(
                    type="statusCode",
                    operator="is",
                    target="200",
                )],
                request_definition=datadog.SyntheticsTestApiStepRequestDefinitionArgs(
                    method="GET",
                    url="http://example.org",
                ),
            ),
        ],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=900,
            accept_self_signed=True,
        ))
    # Example Usage (Synthetics Browser test)
    # Create a new Datadog Synthetics Browser test starting on https://www.example.org
    test_browser = datadog.SyntheticsTest("test_browser",
        name="A Browser test on example.org",
        type="browser",
        status="paused",
        message="Notify @qa",
        device_ids=["laptop_large"],
        locations=["aws:eu-central-1"],
        tags=[],
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            method="GET",
            url="https://app.datadoghq.com",
        ),
        browser_steps=[
            datadog.SyntheticsTestBrowserStepArgs(
                name="Check current url",
                type="assertCurrentUrl",
                params=datadog.SyntheticsTestBrowserStepParamsArgs(
                    check="contains",
                    value="datadoghq",
                ),
            ),
            datadog.SyntheticsTestBrowserStepArgs(
                name="Test a downloaded file",
                type="assertFileDownload",
                params=datadog.SyntheticsTestBrowserStepParamsArgs(
                    file=json.dumps({
                        "md5": "abcdef1234567890",
                        "sizeCheck": {
                            "type": "equals",
                            "value": 1,
                        },
                        "nameCheck": {
                            "type": "contains",
                            "value": ".xls",
                        },
                    }),
                ),
            ),
        ],
        browser_variables=[
            datadog.SyntheticsTestBrowserVariableArgs(
                type="text",
                name="MY_PATTERN_VAR",
                pattern="{{numeric(3)}}",
                example="597",
            ),
            datadog.SyntheticsTestBrowserVariableArgs(
                type="email",
                name="MY_EMAIL_VAR",
                pattern="jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co",
                example="jd8-afe-ydv.4546132139@synthetics.dtdg.co",
            ),
            datadog.SyntheticsTestBrowserVariableArgs(
                type="global",
                name="MY_GLOBAL_VAR",
                id="76636cd1-82e2-4aeb-9cfe-51366a8198a2",
            ),
        ],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=3600,
        ))
    # Example Usage (GRPC API test)
    # Create a new Datadog GRPC API test starting on google.org:50050
    grpc = datadog.SyntheticsTest("grpc",
        type="api",
        subtype="grpc",
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            method="GET",
            host="google.com",
            port=50050,
            service="Hello",
            plain_proto_file="""syntax = "proto3";
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.helloworld";
    option java_outer_classname = "HelloWorldProto";
    option objc_class_prefix = "HLW";
    package helloworld;
    // The greeting service definition.
    service Greeter {
    \x09// Sends a greeting
    \x09rpc SayHello (HelloRequest) returns (HelloReply) {}
    }
    // The request message containing the user's name.
    message HelloRequest {
    \x09string name = 1;
    }
    // The response message containing the greetings
    message HelloReply {
    \x09string message = 1;
    }
    """,
        ),
        request_metadata={
            "header": "value",
        },
        assertions=[
            datadog.SyntheticsTestAssertionArgs(
                type="responseTime",
                operator="lessThan",
                target="2000",
            ),
            datadog.SyntheticsTestAssertionArgs(
                operator="is",
                type="grpcHealthcheckStatus",
                target="1",
            ),
            datadog.SyntheticsTestAssertionArgs(
                operator="is",
                target="proto target",
                type="grpcProto",
            ),
            datadog.SyntheticsTestAssertionArgs(
                operator="is",
                target="123",
                property="property",
                type="grpcMetadata",
            ),
        ],
        locations=["aws:eu-central-1"],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=60,
        ),
        name="GRPC API test",
        message="Notify @datadog.user",
        tags=[
            "foo:bar",
            "baz",
        ],
        status="paused")
    
    package main
    
    import (
    	"encoding/json"
    
    	"github.com/pulumi/pulumi-datadog/sdk/v4/go/datadog"
    	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
    )
    
    func main() {
    	pulumi.Run(func(ctx *pulumi.Context) error {
    		// Example Usage (Synthetics API test)
    		// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    		_, err := datadog.NewSyntheticsTest(ctx, "test_uptime", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("An Uptime test on example.org"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("http"),
    			Status:  pulumi.String("live"),
    			Message: pulumi.String("Notify @pagerduty"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Method: pulumi.String("GET"),
    				Url:    pulumi.String("https://www.example.org"),
    			},
    			RequestHeaders: pulumi.Map{
    				"Content-Type": pulumi.Any("application/json"),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("statusCode"),
    					Operator: pulumi.String("is"),
    					Target:   pulumi.String("200"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(900),
    				Retry: &datadog.SyntheticsTestOptionsListRetryArgs{
    					Count:    pulumi.Int(2),
    					Interval: pulumi.Int(300),
    				},
    				MonitorOptions: &datadog.SyntheticsTestOptionsListMonitorOptionsArgs{
    					RenotifyInterval: pulumi.Int(120),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (Authenticated API test)
    		// Create a new Datadog Synthetics API/HTTP test on https://www.example.org
    		_, err = datadog.NewSyntheticsTest(ctx, "test_api", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("An API test on example.org"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("http"),
    			Status:  pulumi.String("live"),
    			Message: pulumi.String("Notify @pagerduty"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Method: pulumi.String("GET"),
    				Url:    pulumi.String("https://www.example.org"),
    			},
    			RequestHeaders: pulumi.Map{
    				"Content-Type":   pulumi.Any("application/json"),
    				"Authentication": pulumi.Any("Token: 1234566789"),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("statusCode"),
    					Operator: pulumi.String("is"),
    					Target:   pulumi.String("200"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(900),
    				Retry: &datadog.SyntheticsTestOptionsListRetryArgs{
    					Count:    pulumi.Int(2),
    					Interval: pulumi.Int(300),
    				},
    				MonitorOptions: &datadog.SyntheticsTestOptionsListMonitorOptionsArgs{
    					RenotifyInterval: pulumi.Int(120),
    				},
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (Synthetics SSL test)
    		// Create a new Datadog Synthetics API/SSL test on example.org
    		_, err = datadog.NewSyntheticsTest(ctx, "test_ssl", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("An API test on example.org"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("ssl"),
    			Status:  pulumi.String("live"),
    			Message: pulumi.String("Notify @pagerduty"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Host: pulumi.String("example.org"),
    				Port: pulumi.Int(443),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("certificate"),
    					Operator: pulumi.String("isInMoreThan"),
    					Target:   pulumi.String("30"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery:        pulumi.Int(900),
    				AcceptSelfSigned: pulumi.Bool(true),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (Synthetics TCP test)
    		// Create a new Datadog Synthetics API/TCP test on example.org
    		_, err = datadog.NewSyntheticsTest(ctx, "test_tcp", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("An API test on example.org"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("tcp"),
    			Status:  pulumi.String("live"),
    			Message: pulumi.String("Notify @pagerduty"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Host: pulumi.String("example.org"),
    				Port: pulumi.Int(443),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("responseTime"),
    					Operator: pulumi.String("lessThan"),
    					Target:   pulumi.String("2000"),
    				},
    			},
    			ConfigVariables: datadog.SyntheticsTestConfigVariableArray{
    				&datadog.SyntheticsTestConfigVariableArgs{
    					Type: pulumi.String("global"),
    					Name: pulumi.String("MY_GLOBAL_VAR"),
    					Id:   pulumi.String("76636cd1-82e2-4aeb-9cfe-51366a8198a2"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(900),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (Synthetics DNS test)
    		// Create a new Datadog Synthetics API/DNS test on example.org
    		_, err = datadog.NewSyntheticsTest(ctx, "test_dns", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("An API test on example.org"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("dns"),
    			Status:  pulumi.String("live"),
    			Message: pulumi.String("Notify @pagerduty"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Host: pulumi.String("example.org"),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("recordSome"),
    					Operator: pulumi.String("is"),
    					Property: pulumi.String("A"),
    					Target:   pulumi.String("0.0.0.0"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(900),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (Synthetics Multistep API test)
    		// Create a new Datadog Synthetics Multistep API test
    		_, err = datadog.NewSyntheticsTest(ctx, "test_multi_step", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("Multistep API test"),
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("multi"),
    			Status:  pulumi.String("live"),
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("foo"),
    				pulumi.String("env:test"),
    			},
    			ApiSteps: datadog.SyntheticsTestApiStepArray{
    				&datadog.SyntheticsTestApiStepArgs{
    					Name:    pulumi.String("An API test on example.org"),
    					Subtype: pulumi.String("http"),
    					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
    						&datadog.SyntheticsTestApiStepAssertionArgs{
    							Type:     pulumi.String("statusCode"),
    							Operator: pulumi.String("is"),
    							Target:   pulumi.String("200"),
    						},
    					},
    					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
    						Method: pulumi.String("GET"),
    						Url:    pulumi.String("https://example.org"),
    					},
    					RequestHeaders: pulumi.Map{
    						"Content-Type":   pulumi.Any("application/json"),
    						"Authentication": pulumi.Any("Token: 1234566789"),
    					},
    				},
    				&datadog.SyntheticsTestApiStepArgs{
    					Name:    pulumi.String("An API test on example.org"),
    					Subtype: pulumi.String("http"),
    					Assertions: datadog.SyntheticsTestApiStepAssertionArray{
    						&datadog.SyntheticsTestApiStepAssertionArgs{
    							Type:     pulumi.String("statusCode"),
    							Operator: pulumi.String("is"),
    							Target:   pulumi.String("200"),
    						},
    					},
    					RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
    						Method: pulumi.String("GET"),
    						Url:    pulumi.String("http://example.org"),
    					},
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery:        pulumi.Int(900),
    				AcceptSelfSigned: pulumi.Bool(true),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		tmpJSON0, err := json.Marshal(map[string]interface{}{
    			"md5": "abcdef1234567890",
    			"sizeCheck": map[string]interface{}{
    				"type":  "equals",
    				"value": 1,
    			},
    			"nameCheck": map[string]interface{}{
    				"type":  "contains",
    				"value": ".xls",
    			},
    		})
    		if err != nil {
    			return err
    		}
    		json0 := string(tmpJSON0)
    		// Example Usage (Synthetics Browser test)
    		// Create a new Datadog Synthetics Browser test starting on https://www.example.org
    		_, err = datadog.NewSyntheticsTest(ctx, "test_browser", &datadog.SyntheticsTestArgs{
    			Name:    pulumi.String("A Browser test on example.org"),
    			Type:    pulumi.String("browser"),
    			Status:  pulumi.String("paused"),
    			Message: pulumi.String("Notify @qa"),
    			DeviceIds: pulumi.StringArray{
    				pulumi.String("laptop_large"),
    			},
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			Tags: pulumi.StringArray{},
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Method: pulumi.String("GET"),
    				Url:    pulumi.String("https://app.datadoghq.com"),
    			},
    			BrowserSteps: datadog.SyntheticsTestBrowserStepArray{
    				&datadog.SyntheticsTestBrowserStepArgs{
    					Name: pulumi.String("Check current url"),
    					Type: pulumi.String("assertCurrentUrl"),
    					Params: &datadog.SyntheticsTestBrowserStepParamsArgs{
    						Check: pulumi.String("contains"),
    						Value: pulumi.String("datadoghq"),
    					},
    				},
    				&datadog.SyntheticsTestBrowserStepArgs{
    					Name: pulumi.String("Test a downloaded file"),
    					Type: pulumi.String("assertFileDownload"),
    					Params: &datadog.SyntheticsTestBrowserStepParamsArgs{
    						File: pulumi.String(json0),
    					},
    				},
    			},
    			BrowserVariables: datadog.SyntheticsTestBrowserVariableArray{
    				&datadog.SyntheticsTestBrowserVariableArgs{
    					Type:    pulumi.String("text"),
    					Name:    pulumi.String("MY_PATTERN_VAR"),
    					Pattern: pulumi.String("{{numeric(3)}}"),
    					Example: pulumi.String("597"),
    				},
    				&datadog.SyntheticsTestBrowserVariableArgs{
    					Type:    pulumi.String("email"),
    					Name:    pulumi.String("MY_EMAIL_VAR"),
    					Pattern: pulumi.String("jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co"),
    					Example: pulumi.String("jd8-afe-ydv.4546132139@synthetics.dtdg.co"),
    				},
    				&datadog.SyntheticsTestBrowserVariableArgs{
    					Type: pulumi.String("global"),
    					Name: pulumi.String("MY_GLOBAL_VAR"),
    					Id:   pulumi.String("76636cd1-82e2-4aeb-9cfe-51366a8198a2"),
    				},
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(3600),
    			},
    		})
    		if err != nil {
    			return err
    		}
    		// Example Usage (GRPC API test)
    		// Create a new Datadog GRPC API test starting on google.org:50050
    		_, err = datadog.NewSyntheticsTest(ctx, "grpc", &datadog.SyntheticsTestArgs{
    			Type:    pulumi.String("api"),
    			Subtype: pulumi.String("grpc"),
    			RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    				Method:  pulumi.String("GET"),
    				Host:    pulumi.String("google.com"),
    				Port:    pulumi.Int(50050),
    				Service: pulumi.String("Hello"),
    				PlainProtoFile: pulumi.String(`syntax = "proto3";
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.helloworld";
    option java_outer_classname = "HelloWorldProto";
    option objc_class_prefix = "HLW";
    package helloworld;
    // The greeting service definition.
    service Greeter {
    	// Sends a greeting
    	rpc SayHello (HelloRequest) returns (HelloReply) {}
    }
    // The request message containing the user's name.
    message HelloRequest {
    	string name = 1;
    }
    // The response message containing the greetings
    message HelloReply {
    	string message = 1;
    }
    `),
    			},
    			RequestMetadata: pulumi.Map{
    				"header": pulumi.Any("value"),
    			},
    			Assertions: datadog.SyntheticsTestAssertionArray{
    				&datadog.SyntheticsTestAssertionArgs{
    					Type:     pulumi.String("responseTime"),
    					Operator: pulumi.String("lessThan"),
    					Target:   pulumi.String("2000"),
    				},
    				&datadog.SyntheticsTestAssertionArgs{
    					Operator: pulumi.String("is"),
    					Type:     pulumi.String("grpcHealthcheckStatus"),
    					Target:   pulumi.String("1"),
    				},
    				&datadog.SyntheticsTestAssertionArgs{
    					Operator: pulumi.String("is"),
    					Target:   pulumi.String("proto target"),
    					Type:     pulumi.String("grpcProto"),
    				},
    				&datadog.SyntheticsTestAssertionArgs{
    					Operator: pulumi.String("is"),
    					Target:   pulumi.String("123"),
    					Property: pulumi.String("property"),
    					Type:     pulumi.String("grpcMetadata"),
    				},
    			},
    			Locations: pulumi.StringArray{
    				pulumi.String("aws:eu-central-1"),
    			},
    			OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    				TickEvery: pulumi.Int(60),
    			},
    			Name:    pulumi.String("GRPC API test"),
    			Message: pulumi.String("Notify @datadog.user"),
    			Tags: pulumi.StringArray{
    				pulumi.String("foo:bar"),
    				pulumi.String("baz"),
    			},
    			Status: pulumi.String("paused"),
    		})
    		if err != nil {
    			return err
    		}
    		return nil
    	})
    }
    
    using System.Collections.Generic;
    using System.Linq;
    using System.Text.Json;
    using Pulumi;
    using Datadog = Pulumi.Datadog;
    
    return await Deployment.RunAsync(() => 
    {
        // Example Usage (Synthetics API test)
        // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
        var testUptime = new Datadog.SyntheticsTest("test_uptime", new()
        {
            Name = "An Uptime test on example.org",
            Type = "api",
            Subtype = "http",
            Status = "live",
            Message = "Notify @pagerduty",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Method = "GET",
                Url = "https://www.example.org",
            },
            RequestHeaders = 
            {
                { "Content-Type", "application/json" },
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "statusCode",
                    Operator = "is",
                    Target = "200",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
                Retry = new Datadog.Inputs.SyntheticsTestOptionsListRetryArgs
                {
                    Count = 2,
                    Interval = 300,
                },
                MonitorOptions = new Datadog.Inputs.SyntheticsTestOptionsListMonitorOptionsArgs
                {
                    RenotifyInterval = 120,
                },
            },
        });
    
        // Example Usage (Authenticated API test)
        // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
        var testApi = new Datadog.SyntheticsTest("test_api", new()
        {
            Name = "An API test on example.org",
            Type = "api",
            Subtype = "http",
            Status = "live",
            Message = "Notify @pagerduty",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Method = "GET",
                Url = "https://www.example.org",
            },
            RequestHeaders = 
            {
                { "Content-Type", "application/json" },
                { "Authentication", "Token: 1234566789" },
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "statusCode",
                    Operator = "is",
                    Target = "200",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
                Retry = new Datadog.Inputs.SyntheticsTestOptionsListRetryArgs
                {
                    Count = 2,
                    Interval = 300,
                },
                MonitorOptions = new Datadog.Inputs.SyntheticsTestOptionsListMonitorOptionsArgs
                {
                    RenotifyInterval = 120,
                },
            },
        });
    
        // Example Usage (Synthetics SSL test)
        // Create a new Datadog Synthetics API/SSL test on example.org
        var testSsl = new Datadog.SyntheticsTest("test_ssl", new()
        {
            Name = "An API test on example.org",
            Type = "api",
            Subtype = "ssl",
            Status = "live",
            Message = "Notify @pagerduty",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Host = "example.org",
                Port = 443,
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "certificate",
                    Operator = "isInMoreThan",
                    Target = "30",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
                AcceptSelfSigned = true,
            },
        });
    
        // Example Usage (Synthetics TCP test)
        // Create a new Datadog Synthetics API/TCP test on example.org
        var testTcp = new Datadog.SyntheticsTest("test_tcp", new()
        {
            Name = "An API test on example.org",
            Type = "api",
            Subtype = "tcp",
            Status = "live",
            Message = "Notify @pagerduty",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Host = "example.org",
                Port = 443,
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "responseTime",
                    Operator = "lessThan",
                    Target = "2000",
                },
            },
            ConfigVariables = new[]
            {
                new Datadog.Inputs.SyntheticsTestConfigVariableArgs
                {
                    Type = "global",
                    Name = "MY_GLOBAL_VAR",
                    Id = "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
            },
        });
    
        // Example Usage (Synthetics DNS test)
        // Create a new Datadog Synthetics API/DNS test on example.org
        var testDns = new Datadog.SyntheticsTest("test_dns", new()
        {
            Name = "An API test on example.org",
            Type = "api",
            Subtype = "dns",
            Status = "live",
            Message = "Notify @pagerduty",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Host = "example.org",
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "recordSome",
                    Operator = "is",
                    Property = "A",
                    Target = "0.0.0.0",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
            },
        });
    
        // Example Usage (Synthetics Multistep API test)
        // Create a new Datadog Synthetics Multistep API test
        var testMultiStep = new Datadog.SyntheticsTest("test_multi_step", new()
        {
            Name = "Multistep API test",
            Type = "api",
            Subtype = "multi",
            Status = "live",
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[]
            {
                "foo:bar",
                "foo",
                "env:test",
            },
            ApiSteps = new[]
            {
                new Datadog.Inputs.SyntheticsTestApiStepArgs
                {
                    Name = "An API test on example.org",
                    Subtype = "http",
                    Assertions = new[]
                    {
                        new Datadog.Inputs.SyntheticsTestApiStepAssertionArgs
                        {
                            Type = "statusCode",
                            Operator = "is",
                            Target = "200",
                        },
                    },
                    RequestDefinition = new Datadog.Inputs.SyntheticsTestApiStepRequestDefinitionArgs
                    {
                        Method = "GET",
                        Url = "https://example.org",
                    },
                    RequestHeaders = 
                    {
                        { "Content-Type", "application/json" },
                        { "Authentication", "Token: 1234566789" },
                    },
                },
                new Datadog.Inputs.SyntheticsTestApiStepArgs
                {
                    Name = "An API test on example.org",
                    Subtype = "http",
                    Assertions = new[]
                    {
                        new Datadog.Inputs.SyntheticsTestApiStepAssertionArgs
                        {
                            Type = "statusCode",
                            Operator = "is",
                            Target = "200",
                        },
                    },
                    RequestDefinition = new Datadog.Inputs.SyntheticsTestApiStepRequestDefinitionArgs
                    {
                        Method = "GET",
                        Url = "http://example.org",
                    },
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 900,
                AcceptSelfSigned = true,
            },
        });
    
        // Example Usage (Synthetics Browser test)
        // Create a new Datadog Synthetics Browser test starting on https://www.example.org
        var testBrowser = new Datadog.SyntheticsTest("test_browser", new()
        {
            Name = "A Browser test on example.org",
            Type = "browser",
            Status = "paused",
            Message = "Notify @qa",
            DeviceIds = new[]
            {
                "laptop_large",
            },
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            Tags = new[] {},
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Method = "GET",
                Url = "https://app.datadoghq.com",
            },
            BrowserSteps = new[]
            {
                new Datadog.Inputs.SyntheticsTestBrowserStepArgs
                {
                    Name = "Check current url",
                    Type = "assertCurrentUrl",
                    Params = new Datadog.Inputs.SyntheticsTestBrowserStepParamsArgs
                    {
                        Check = "contains",
                        Value = "datadoghq",
                    },
                },
                new Datadog.Inputs.SyntheticsTestBrowserStepArgs
                {
                    Name = "Test a downloaded file",
                    Type = "assertFileDownload",
                    Params = new Datadog.Inputs.SyntheticsTestBrowserStepParamsArgs
                    {
                        File = JsonSerializer.Serialize(new Dictionary<string, object?>
                        {
                            ["md5"] = "abcdef1234567890",
                            ["sizeCheck"] = new Dictionary<string, object?>
                            {
                                ["type"] = "equals",
                                ["value"] = 1,
                            },
                            ["nameCheck"] = new Dictionary<string, object?>
                            {
                                ["type"] = "contains",
                                ["value"] = ".xls",
                            },
                        }),
                    },
                },
            },
            BrowserVariables = new[]
            {
                new Datadog.Inputs.SyntheticsTestBrowserVariableArgs
                {
                    Type = "text",
                    Name = "MY_PATTERN_VAR",
                    Pattern = "{{numeric(3)}}",
                    Example = "597",
                },
                new Datadog.Inputs.SyntheticsTestBrowserVariableArgs
                {
                    Type = "email",
                    Name = "MY_EMAIL_VAR",
                    Pattern = "jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co",
                    Example = "jd8-afe-ydv.4546132139@synthetics.dtdg.co",
                },
                new Datadog.Inputs.SyntheticsTestBrowserVariableArgs
                {
                    Type = "global",
                    Name = "MY_GLOBAL_VAR",
                    Id = "76636cd1-82e2-4aeb-9cfe-51366a8198a2",
                },
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 3600,
            },
        });
    
        // Example Usage (GRPC API test)
        // Create a new Datadog GRPC API test starting on google.org:50050
        var grpc = new Datadog.SyntheticsTest("grpc", new()
        {
            Type = "api",
            Subtype = "grpc",
            RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
            {
                Method = "GET",
                Host = "google.com",
                Port = 50050,
                Service = "Hello",
                PlainProtoFile = @"syntax = ""proto3"";
    option java_multiple_files = true;
    option java_package = ""io.grpc.examples.helloworld"";
    option java_outer_classname = ""HelloWorldProto"";
    option objc_class_prefix = ""HLW"";
    package helloworld;
    // The greeting service definition.
    service Greeter {
    	// Sends a greeting
    	rpc SayHello (HelloRequest) returns (HelloReply) {}
    }
    // The request message containing the user's name.
    message HelloRequest {
    	string name = 1;
    }
    // The response message containing the greetings
    message HelloReply {
    	string message = 1;
    }
    ",
            },
            RequestMetadata = 
            {
                { "header", "value" },
            },
            Assertions = new[]
            {
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Type = "responseTime",
                    Operator = "lessThan",
                    Target = "2000",
                },
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Operator = "is",
                    Type = "grpcHealthcheckStatus",
                    Target = "1",
                },
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Operator = "is",
                    Target = "proto target",
                    Type = "grpcProto",
                },
                new Datadog.Inputs.SyntheticsTestAssertionArgs
                {
                    Operator = "is",
                    Target = "123",
                    Property = "property",
                    Type = "grpcMetadata",
                },
            },
            Locations = new[]
            {
                "aws:eu-central-1",
            },
            OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
            {
                TickEvery = 60,
            },
            Name = "GRPC API test",
            Message = "Notify @datadog.user",
            Tags = new[]
            {
                "foo:bar",
                "baz",
            },
            Status = "paused",
        });
    
    });
    
    package generated_program;
    
    import com.pulumi.Context;
    import com.pulumi.Pulumi;
    import com.pulumi.core.Output;
    import com.pulumi.datadog.SyntheticsTest;
    import com.pulumi.datadog.SyntheticsTestArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestRequestDefinitionArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestAssertionArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestOptionsListArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestOptionsListRetryArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestOptionsListMonitorOptionsArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestConfigVariableArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestApiStepArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestApiStepRequestDefinitionArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestBrowserStepArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestBrowserStepParamsArgs;
    import com.pulumi.datadog.inputs.SyntheticsTestBrowserVariableArgs;
    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) {
            // Example Usage (Synthetics API test)
            // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
            var testUptime = new SyntheticsTest("testUptime", SyntheticsTestArgs.builder()        
                .name("An Uptime test on example.org")
                .type("api")
                .subtype("http")
                .status("live")
                .message("Notify @pagerduty")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .method("GET")
                    .url("https://www.example.org")
                    .build())
                .requestHeaders(Map.of("Content-Type", "application/json"))
                .assertions(SyntheticsTestAssertionArgs.builder()
                    .type("statusCode")
                    .operator("is")
                    .target("200")
                    .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .retry(SyntheticsTestOptionsListRetryArgs.builder()
                        .count(2)
                        .interval(300)
                        .build())
                    .monitorOptions(SyntheticsTestOptionsListMonitorOptionsArgs.builder()
                        .renotifyInterval(120)
                        .build())
                    .build())
                .build());
    
            // Example Usage (Authenticated API test)
            // Create a new Datadog Synthetics API/HTTP test on https://www.example.org
            var testApi = new SyntheticsTest("testApi", SyntheticsTestArgs.builder()        
                .name("An API test on example.org")
                .type("api")
                .subtype("http")
                .status("live")
                .message("Notify @pagerduty")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .method("GET")
                    .url("https://www.example.org")
                    .build())
                .requestHeaders(Map.ofEntries(
                    Map.entry("Content-Type", "application/json"),
                    Map.entry("Authentication", "Token: 1234566789")
                ))
                .assertions(SyntheticsTestAssertionArgs.builder()
                    .type("statusCode")
                    .operator("is")
                    .target("200")
                    .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .retry(SyntheticsTestOptionsListRetryArgs.builder()
                        .count(2)
                        .interval(300)
                        .build())
                    .monitorOptions(SyntheticsTestOptionsListMonitorOptionsArgs.builder()
                        .renotifyInterval(120)
                        .build())
                    .build())
                .build());
    
            // Example Usage (Synthetics SSL test)
            // Create a new Datadog Synthetics API/SSL test on example.org
            var testSsl = new SyntheticsTest("testSsl", SyntheticsTestArgs.builder()        
                .name("An API test on example.org")
                .type("api")
                .subtype("ssl")
                .status("live")
                .message("Notify @pagerduty")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .host("example.org")
                    .port(443)
                    .build())
                .assertions(SyntheticsTestAssertionArgs.builder()
                    .type("certificate")
                    .operator("isInMoreThan")
                    .target(30)
                    .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .acceptSelfSigned(true)
                    .build())
                .build());
    
            // Example Usage (Synthetics TCP test)
            // Create a new Datadog Synthetics API/TCP test on example.org
            var testTcp = new SyntheticsTest("testTcp", SyntheticsTestArgs.builder()        
                .name("An API test on example.org")
                .type("api")
                .subtype("tcp")
                .status("live")
                .message("Notify @pagerduty")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .host("example.org")
                    .port(443)
                    .build())
                .assertions(SyntheticsTestAssertionArgs.builder()
                    .type("responseTime")
                    .operator("lessThan")
                    .target(2000)
                    .build())
                .configVariables(SyntheticsTestConfigVariableArgs.builder()
                    .type("global")
                    .name("MY_GLOBAL_VAR")
                    .id("76636cd1-82e2-4aeb-9cfe-51366a8198a2")
                    .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .build())
                .build());
    
            // Example Usage (Synthetics DNS test)
            // Create a new Datadog Synthetics API/DNS test on example.org
            var testDns = new SyntheticsTest("testDns", SyntheticsTestArgs.builder()        
                .name("An API test on example.org")
                .type("api")
                .subtype("dns")
                .status("live")
                .message("Notify @pagerduty")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .host("example.org")
                    .build())
                .assertions(SyntheticsTestAssertionArgs.builder()
                    .type("recordSome")
                    .operator("is")
                    .property("A")
                    .target("0.0.0.0")
                    .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .build())
                .build());
    
            // Example Usage (Synthetics Multistep API test)
            // Create a new Datadog Synthetics Multistep API test
            var testMultiStep = new SyntheticsTest("testMultiStep", SyntheticsTestArgs.builder()        
                .name("Multistep API test")
                .type("api")
                .subtype("multi")
                .status("live")
                .locations("aws:eu-central-1")
                .tags(            
                    "foo:bar",
                    "foo",
                    "env:test")
                .apiSteps(            
                    SyntheticsTestApiStepArgs.builder()
                        .name("An API test on example.org")
                        .subtype("http")
                        .assertions(SyntheticsTestApiStepAssertionArgs.builder()
                            .type("statusCode")
                            .operator("is")
                            .target("200")
                            .build())
                        .requestDefinition(SyntheticsTestApiStepRequestDefinitionArgs.builder()
                            .method("GET")
                            .url("https://example.org")
                            .build())
                        .requestHeaders(Map.ofEntries(
                            Map.entry("Content-Type", "application/json"),
                            Map.entry("Authentication", "Token: 1234566789")
                        ))
                        .build(),
                    SyntheticsTestApiStepArgs.builder()
                        .name("An API test on example.org")
                        .subtype("http")
                        .assertions(SyntheticsTestApiStepAssertionArgs.builder()
                            .type("statusCode")
                            .operator("is")
                            .target("200")
                            .build())
                        .requestDefinition(SyntheticsTestApiStepRequestDefinitionArgs.builder()
                            .method("GET")
                            .url("http://example.org")
                            .build())
                        .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(900)
                    .acceptSelfSigned(true)
                    .build())
                .build());
    
            // Example Usage (Synthetics Browser test)
            // Create a new Datadog Synthetics Browser test starting on https://www.example.org
            var testBrowser = new SyntheticsTest("testBrowser", SyntheticsTestArgs.builder()        
                .name("A Browser test on example.org")
                .type("browser")
                .status("paused")
                .message("Notify @qa")
                .deviceIds("laptop_large")
                .locations("aws:eu-central-1")
                .tags()
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .method("GET")
                    .url("https://app.datadoghq.com")
                    .build())
                .browserSteps(            
                    SyntheticsTestBrowserStepArgs.builder()
                        .name("Check current url")
                        .type("assertCurrentUrl")
                        .params(SyntheticsTestBrowserStepParamsArgs.builder()
                            .check("contains")
                            .value("datadoghq")
                            .build())
                        .build(),
                    SyntheticsTestBrowserStepArgs.builder()
                        .name("Test a downloaded file")
                        .type("assertFileDownload")
                        .params(SyntheticsTestBrowserStepParamsArgs.builder()
                            .file(serializeJson(
                                jsonObject(
                                    jsonProperty("md5", "abcdef1234567890"),
                                    jsonProperty("sizeCheck", jsonObject(
                                        jsonProperty("type", "equals"),
                                        jsonProperty("value", 1)
                                    )),
                                    jsonProperty("nameCheck", jsonObject(
                                        jsonProperty("type", "contains"),
                                        jsonProperty("value", ".xls")
                                    ))
                                )))
                            .build())
                        .build())
                .browserVariables(            
                    SyntheticsTestBrowserVariableArgs.builder()
                        .type("text")
                        .name("MY_PATTERN_VAR")
                        .pattern("{{numeric(3)}}")
                        .example("597")
                        .build(),
                    SyntheticsTestBrowserVariableArgs.builder()
                        .type("email")
                        .name("MY_EMAIL_VAR")
                        .pattern("jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co")
                        .example("jd8-afe-ydv.4546132139@synthetics.dtdg.co")
                        .build(),
                    SyntheticsTestBrowserVariableArgs.builder()
                        .type("global")
                        .name("MY_GLOBAL_VAR")
                        .id("76636cd1-82e2-4aeb-9cfe-51366a8198a2")
                        .build())
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(3600)
                    .build())
                .build());
    
            // Example Usage (GRPC API test)
            // Create a new Datadog GRPC API test starting on google.org:50050
            var grpc = new SyntheticsTest("grpc", SyntheticsTestArgs.builder()        
                .type("api")
                .subtype("grpc")
                .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
                    .method("GET")
                    .host("google.com")
                    .port(50050)
                    .service("Hello")
                    .plainProtoFile("""
    syntax = "proto3";
    option java_multiple_files = true;
    option java_package = "io.grpc.examples.helloworld";
    option java_outer_classname = "HelloWorldProto";
    option objc_class_prefix = "HLW";
    package helloworld;
    // The greeting service definition.
    service Greeter {
    	// Sends a greeting
    	rpc SayHello (HelloRequest) returns (HelloReply) {}
    }
    // The request message containing the user's name.
    message HelloRequest {
    	string name = 1;
    }
    // The response message containing the greetings
    message HelloReply {
    	string message = 1;
    }
                    """)
                    .build())
                .requestMetadata(Map.of("header", "value"))
                .assertions(            
                    SyntheticsTestAssertionArgs.builder()
                        .type("responseTime")
                        .operator("lessThan")
                        .target("2000")
                        .build(),
                    SyntheticsTestAssertionArgs.builder()
                        .operator("is")
                        .type("grpcHealthcheckStatus")
                        .target(1)
                        .build(),
                    SyntheticsTestAssertionArgs.builder()
                        .operator("is")
                        .target("proto target")
                        .type("grpcProto")
                        .build(),
                    SyntheticsTestAssertionArgs.builder()
                        .operator("is")
                        .target("123")
                        .property("property")
                        .type("grpcMetadata")
                        .build())
                .locations("aws:eu-central-1")
                .optionsList(SyntheticsTestOptionsListArgs.builder()
                    .tickEvery(60)
                    .build())
                .name("GRPC API test")
                .message("Notify @datadog.user")
                .tags(            
                    "foo:bar",
                    "baz")
                .status("paused")
                .build());
    
        }
    }
    
    resources:
      # Example Usage (Synthetics API test)
      # Create a new Datadog Synthetics API/HTTP test on https://www.example.org
      testUptime:
        type: datadog:SyntheticsTest
        name: test_uptime
        properties:
          name: An Uptime test on example.org
          type: api
          subtype: http
          status: live
          message: Notify @pagerduty
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          requestDefinition:
            method: GET
            url: https://www.example.org
          requestHeaders:
            Content-Type: application/json
          assertions:
            - type: statusCode
              operator: is
              target: '200'
          optionsList:
            tickEvery: 900
            retry:
              count: 2
              interval: 300
            monitorOptions:
              renotifyInterval: 120
      # Example Usage (Authenticated API test)
      # Create a new Datadog Synthetics API/HTTP test on https://www.example.org
      testApi:
        type: datadog:SyntheticsTest
        name: test_api
        properties:
          name: An API test on example.org
          type: api
          subtype: http
          status: live
          message: Notify @pagerduty
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          requestDefinition:
            method: GET
            url: https://www.example.org
          requestHeaders:
            Content-Type: application/json
            Authentication: 'Token: 1234566789'
          assertions:
            - type: statusCode
              operator: is
              target: '200'
          optionsList:
            tickEvery: 900
            retry:
              count: 2
              interval: 300
            monitorOptions:
              renotifyInterval: 120
      # Example Usage (Synthetics SSL test)
      # Create a new Datadog Synthetics API/SSL test on example.org
      testSsl:
        type: datadog:SyntheticsTest
        name: test_ssl
        properties:
          name: An API test on example.org
          type: api
          subtype: ssl
          status: live
          message: Notify @pagerduty
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          requestDefinition:
            host: example.org
            port: 443
          assertions:
            - type: certificate
              operator: isInMoreThan
              target: 30
          optionsList:
            tickEvery: 900
            acceptSelfSigned: true
      # Example Usage (Synthetics TCP test)
      # Create a new Datadog Synthetics API/TCP test on example.org
      testTcp:
        type: datadog:SyntheticsTest
        name: test_tcp
        properties:
          name: An API test on example.org
          type: api
          subtype: tcp
          status: live
          message: Notify @pagerduty
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          requestDefinition:
            host: example.org
            port: 443
          assertions:
            - type: responseTime
              operator: lessThan
              target: 2000
          configVariables:
            - type: global
              name: MY_GLOBAL_VAR
              id: 76636cd1-82e2-4aeb-9cfe-51366a8198a2
          optionsList:
            tickEvery: 900
      # Example Usage (Synthetics DNS test)
      # Create a new Datadog Synthetics API/DNS test on example.org
      testDns:
        type: datadog:SyntheticsTest
        name: test_dns
        properties:
          name: An API test on example.org
          type: api
          subtype: dns
          status: live
          message: Notify @pagerduty
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          requestDefinition:
            host: example.org
          assertions:
            - type: recordSome
              operator: is
              property: A
              target: 0.0.0.0
          optionsList:
            tickEvery: 900
      # Example Usage (Synthetics Multistep API test)
      # Create a new Datadog Synthetics Multistep API test
      testMultiStep:
        type: datadog:SyntheticsTest
        name: test_multi_step
        properties:
          name: Multistep API test
          type: api
          subtype: multi
          status: live
          locations:
            - aws:eu-central-1
          tags:
            - foo:bar
            - foo
            - env:test
          apiSteps:
            - name: An API test on example.org
              subtype: http
              assertions:
                - type: statusCode
                  operator: is
                  target: '200'
              requestDefinition:
                method: GET
                url: https://example.org
              requestHeaders:
                Content-Type: application/json
                Authentication: 'Token: 1234566789'
            - name: An API test on example.org
              subtype: http
              assertions:
                - type: statusCode
                  operator: is
                  target: '200'
              requestDefinition:
                method: GET
                url: http://example.org
          optionsList:
            tickEvery: 900
            acceptSelfSigned: true
      # Example Usage (Synthetics Browser test)
      # Create a new Datadog Synthetics Browser test starting on https://www.example.org
      testBrowser:
        type: datadog:SyntheticsTest
        name: test_browser
        properties:
          name: A Browser test on example.org
          type: browser
          status: paused
          message: Notify @qa
          deviceIds:
            - laptop_large
          locations:
            - aws:eu-central-1
          tags: []
          requestDefinition:
            method: GET
            url: https://app.datadoghq.com
          browserSteps:
            - name: Check current url
              type: assertCurrentUrl
              params:
                check: contains
                value: datadoghq
            - name: Test a downloaded file
              type: assertFileDownload
              params:
                file:
                  fn::toJSON:
                    md5: abcdef1234567890
                    sizeCheck:
                      type: equals
                      value: 1
                    nameCheck:
                      type: contains
                      value: .xls
          browserVariables:
            - type: text
              name: MY_PATTERN_VAR
              pattern: '{{numeric(3)}}'
              example: '597'
            - type: email
              name: MY_EMAIL_VAR
              pattern: jd8-afe-ydv.{{ numeric(10) }}@synthetics.dtdg.co
              example: jd8-afe-ydv.4546132139@synthetics.dtdg.co
            - type: global
              name: MY_GLOBAL_VAR
              id: 76636cd1-82e2-4aeb-9cfe-51366a8198a2
          optionsList:
            tickEvery: 3600
      # Example Usage (GRPC API test)
      # Create a new Datadog GRPC API test starting on google.org:50050
      grpc:
        type: datadog:SyntheticsTest
        properties:
          type: api
          subtype: grpc
          requestDefinition:
            method: GET
            host: google.com
            port: 50050
            service: Hello
            plainProtoFile: |
              syntax = "proto3";
              option java_multiple_files = true;
              option java_package = "io.grpc.examples.helloworld";
              option java_outer_classname = "HelloWorldProto";
              option objc_class_prefix = "HLW";
              package helloworld;
              // The greeting service definition.
              service Greeter {
              	// Sends a greeting
              	rpc SayHello (HelloRequest) returns (HelloReply) {}
              }
              // The request message containing the user's name.
              message HelloRequest {
              	string name = 1;
              }
              // The response message containing the greetings
              message HelloReply {
              	string message = 1;
              }          
          requestMetadata:
            header: value
          assertions:
            - type: responseTime
              operator: lessThan
              target: '2000'
            - operator: is
              type: grpcHealthcheckStatus
              target: 1
            - operator: is
              target: proto target
              type: grpcProto
            - operator: is
              target: '123'
              property: property
              type: grpcMetadata
          locations:
            - aws:eu-central-1
          optionsList:
            tickEvery: 60
          name: GRPC API test
          message: Notify @datadog.user
          tags:
            - foo:bar
            - baz
          status: paused
    

    Create SyntheticsTest Resource

    Resources are created with functions called constructors. To learn more about declaring and configuring resources, see Resources.

    Constructor syntax

    new SyntheticsTest(name: string, args: SyntheticsTestArgs, opts?: CustomResourceOptions);
    @overload
    def SyntheticsTest(resource_name: str,
                       args: SyntheticsTestArgs,
                       opts: Optional[ResourceOptions] = None)
    
    @overload
    def SyntheticsTest(resource_name: str,
                       opts: Optional[ResourceOptions] = None,
                       locations: Optional[Sequence[str]] = None,
                       type: Optional[str] = None,
                       status: Optional[str] = None,
                       name: Optional[str] = None,
                       request_basicauth: Optional[SyntheticsTestRequestBasicauthArgs] = None,
                       request_headers: Optional[Mapping[str, Any]] = None,
                       config_variables: Optional[Sequence[SyntheticsTestConfigVariableArgs]] = None,
                       message: Optional[str] = None,
                       browser_variables: Optional[Sequence[SyntheticsTestBrowserVariableArgs]] = None,
                       options_list: Optional[SyntheticsTestOptionsListArgs] = None,
                       api_steps: Optional[Sequence[SyntheticsTestApiStepArgs]] = None,
                       request_client_certificate: Optional[SyntheticsTestRequestClientCertificateArgs] = None,
                       request_definition: Optional[SyntheticsTestRequestDefinitionArgs] = None,
                       device_ids: Optional[Sequence[str]] = None,
                       request_metadata: Optional[Mapping[str, Any]] = None,
                       request_proxy: Optional[SyntheticsTestRequestProxyArgs] = None,
                       request_query: Optional[Mapping[str, Any]] = None,
                       set_cookie: Optional[str] = None,
                       browser_steps: Optional[Sequence[SyntheticsTestBrowserStepArgs]] = None,
                       subtype: Optional[str] = None,
                       tags: Optional[Sequence[str]] = None,
                       assertions: Optional[Sequence[SyntheticsTestAssertionArgs]] = None)
    func NewSyntheticsTest(ctx *Context, name string, args SyntheticsTestArgs, opts ...ResourceOption) (*SyntheticsTest, error)
    public SyntheticsTest(string name, SyntheticsTestArgs args, CustomResourceOptions? opts = null)
    public SyntheticsTest(String name, SyntheticsTestArgs args)
    public SyntheticsTest(String name, SyntheticsTestArgs args, CustomResourceOptions options)
    
    type: datadog:SyntheticsTest
    properties: # The arguments to resource properties.
    options: # Bag of options to control resource's behavior.
    
    

    Parameters

    name string
    The unique name of the resource.
    args SyntheticsTestArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    resource_name str
    The unique name of the resource.
    args SyntheticsTestArgs
    The arguments to resource properties.
    opts ResourceOptions
    Bag of options to control resource's behavior.
    ctx Context
    Context object for the current deployment.
    name string
    The unique name of the resource.
    args SyntheticsTestArgs
    The arguments to resource properties.
    opts ResourceOption
    Bag of options to control resource's behavior.
    name string
    The unique name of the resource.
    args SyntheticsTestArgs
    The arguments to resource properties.
    opts CustomResourceOptions
    Bag of options to control resource's behavior.
    name String
    The unique name of the resource.
    args SyntheticsTestArgs
    The arguments to resource properties.
    options CustomResourceOptions
    Bag of options to control resource's behavior.

    Example

    The following reference example uses placeholder values for all input properties.

    var syntheticsTestResource = new Datadog.SyntheticsTest("syntheticsTestResource", new()
    {
        Locations = new[]
        {
            "string",
        },
        Type = "string",
        Status = "string",
        Name = "string",
        RequestBasicauth = new Datadog.Inputs.SyntheticsTestRequestBasicauthArgs
        {
            AccessKey = "string",
            AccessTokenUrl = "string",
            Audience = "string",
            ClientId = "string",
            ClientSecret = "string",
            Domain = "string",
            Password = "string",
            Region = "string",
            Resource = "string",
            Scope = "string",
            SecretKey = "string",
            ServiceName = "string",
            SessionToken = "string",
            TokenApiAuthentication = "string",
            Type = "string",
            Username = "string",
            Workstation = "string",
        },
        RequestHeaders = 
        {
            { "string", "any" },
        },
        ConfigVariables = new[]
        {
            new Datadog.Inputs.SyntheticsTestConfigVariableArgs
            {
                Name = "string",
                Type = "string",
                Example = "string",
                Id = "string",
                Pattern = "string",
                Secure = false,
            },
        },
        Message = "string",
        BrowserVariables = new[]
        {
            new Datadog.Inputs.SyntheticsTestBrowserVariableArgs
            {
                Name = "string",
                Type = "string",
                Example = "string",
                Id = "string",
                Pattern = "string",
                Secure = false,
            },
        },
        OptionsList = new Datadog.Inputs.SyntheticsTestOptionsListArgs
        {
            TickEvery = 0,
            MinFailureDuration = 0,
            RumSettings = new Datadog.Inputs.SyntheticsTestOptionsListRumSettingsArgs
            {
                IsEnabled = false,
                ApplicationId = "string",
                ClientTokenId = 0,
            },
            Ci = new Datadog.Inputs.SyntheticsTestOptionsListCiArgs
            {
                ExecutionRule = "string",
            },
            DisableCors = false,
            DisableCsp = false,
            FollowRedirects = false,
            HttpVersion = "string",
            MinLocationFailed = 0,
            AllowInsecure = false,
            CheckCertificateRevocation = false,
            IgnoreServerCertificateError = false,
            MonitorName = "string",
            MonitorOptions = new Datadog.Inputs.SyntheticsTestOptionsListMonitorOptionsArgs
            {
                RenotifyInterval = 0,
            },
            MonitorPriority = 0,
            NoScreenshot = false,
            RestrictedRoles = new[]
            {
                "string",
            },
            Retry = new Datadog.Inputs.SyntheticsTestOptionsListRetryArgs
            {
                Count = 0,
                Interval = 0,
            },
            AcceptSelfSigned = false,
            Scheduling = new Datadog.Inputs.SyntheticsTestOptionsListSchedulingArgs
            {
                Timeframes = new[]
                {
                    new Datadog.Inputs.SyntheticsTestOptionsListSchedulingTimeframeArgs
                    {
                        Day = 0,
                        From = "string",
                        To = "string",
                    },
                },
                Timezone = "string",
            },
            InitialNavigationTimeout = 0,
        },
        ApiSteps = new[]
        {
            new Datadog.Inputs.SyntheticsTestApiStepArgs
            {
                Name = "string",
                RequestClientCertificate = new Datadog.Inputs.SyntheticsTestApiStepRequestClientCertificateArgs
                {
                    Cert = new Datadog.Inputs.SyntheticsTestApiStepRequestClientCertificateCertArgs
                    {
                        Content = "string",
                        Filename = "string",
                    },
                    Key = new Datadog.Inputs.SyntheticsTestApiStepRequestClientCertificateKeyArgs
                    {
                        Content = "string",
                        Filename = "string",
                    },
                },
                ExtractedValues = new[]
                {
                    new Datadog.Inputs.SyntheticsTestApiStepExtractedValueArgs
                    {
                        Name = "string",
                        Parser = new Datadog.Inputs.SyntheticsTestApiStepExtractedValueParserArgs
                        {
                            Type = "string",
                            Value = "string",
                        },
                        Type = "string",
                        Field = "string",
                        Secure = false,
                    },
                },
                IsCritical = false,
                Assertions = new[]
                {
                    new Datadog.Inputs.SyntheticsTestApiStepAssertionArgs
                    {
                        Operator = "string",
                        Type = "string",
                        Property = "string",
                        Target = "string",
                        Targetjsonpath = new Datadog.Inputs.SyntheticsTestApiStepAssertionTargetjsonpathArgs
                        {
                            Jsonpath = "string",
                            Operator = "string",
                            Targetvalue = "string",
                        },
                        Targetxpath = new Datadog.Inputs.SyntheticsTestApiStepAssertionTargetxpathArgs
                        {
                            Operator = "string",
                            Xpath = "string",
                            Targetvalue = "string",
                        },
                        TimingsScope = "string",
                    },
                },
                RequestBasicauth = new Datadog.Inputs.SyntheticsTestApiStepRequestBasicauthArgs
                {
                    AccessKey = "string",
                    AccessTokenUrl = "string",
                    Audience = "string",
                    ClientId = "string",
                    ClientSecret = "string",
                    Domain = "string",
                    Password = "string",
                    Region = "string",
                    Resource = "string",
                    Scope = "string",
                    SecretKey = "string",
                    ServiceName = "string",
                    SessionToken = "string",
                    TokenApiAuthentication = "string",
                    Type = "string",
                    Username = "string",
                    Workstation = "string",
                },
                AllowFailure = false,
                RequestDefinition = new Datadog.Inputs.SyntheticsTestApiStepRequestDefinitionArgs
                {
                    AllowInsecure = false,
                    Body = "string",
                    BodyType = "string",
                    CallType = "string",
                    CertificateDomains = new[]
                    {
                        "string",
                    },
                    DnsServer = "string",
                    DnsServerPort = 0,
                    FollowRedirects = false,
                    Host = "string",
                    HttpVersion = "string",
                    Message = "string",
                    Method = "string",
                    NoSavingResponseBody = false,
                    NumberOfPackets = 0,
                    PersistCookies = false,
                    PlainProtoFile = "string",
                    Port = 0,
                    Servername = "string",
                    Service = "string",
                    ShouldTrackHops = false,
                    Timeout = 0,
                    Url = "string",
                },
                RequestHeaders = 
                {
                    { "string", "any" },
                },
                RequestProxy = new Datadog.Inputs.SyntheticsTestApiStepRequestProxyArgs
                {
                    Url = "string",
                    Headers = 
                    {
                        { "string", "any" },
                    },
                },
                RequestQuery = 
                {
                    { "string", "any" },
                },
                Retry = new Datadog.Inputs.SyntheticsTestApiStepRetryArgs
                {
                    Count = 0,
                    Interval = 0,
                },
                Subtype = "string",
            },
        },
        RequestClientCertificate = new Datadog.Inputs.SyntheticsTestRequestClientCertificateArgs
        {
            Cert = new Datadog.Inputs.SyntheticsTestRequestClientCertificateCertArgs
            {
                Content = "string",
                Filename = "string",
            },
            Key = new Datadog.Inputs.SyntheticsTestRequestClientCertificateKeyArgs
            {
                Content = "string",
                Filename = "string",
            },
        },
        RequestDefinition = new Datadog.Inputs.SyntheticsTestRequestDefinitionArgs
        {
            Body = "string",
            BodyType = "string",
            CallType = "string",
            CertificateDomains = new[]
            {
                "string",
            },
            DnsServer = "string",
            DnsServerPort = 0,
            Host = "string",
            HttpVersion = "string",
            Message = "string",
            Method = "string",
            NoSavingResponseBody = false,
            NumberOfPackets = 0,
            PersistCookies = false,
            PlainProtoFile = "string",
            Port = 0,
            Servername = "string",
            Service = "string",
            ShouldTrackHops = false,
            Timeout = 0,
            Url = "string",
        },
        DeviceIds = new[]
        {
            "string",
        },
        RequestMetadata = 
        {
            { "string", "any" },
        },
        RequestProxy = new Datadog.Inputs.SyntheticsTestRequestProxyArgs
        {
            Url = "string",
            Headers = 
            {
                { "string", "any" },
            },
        },
        RequestQuery = 
        {
            { "string", "any" },
        },
        SetCookie = "string",
        BrowserSteps = new[]
        {
            new Datadog.Inputs.SyntheticsTestBrowserStepArgs
            {
                Name = "string",
                Params = new Datadog.Inputs.SyntheticsTestBrowserStepParamsArgs
                {
                    Attribute = "string",
                    Check = "string",
                    ClickType = "string",
                    Code = "string",
                    Delay = 0,
                    Element = "string",
                    ElementUserLocator = new Datadog.Inputs.SyntheticsTestBrowserStepParamsElementUserLocatorArgs
                    {
                        Value = new Datadog.Inputs.SyntheticsTestBrowserStepParamsElementUserLocatorValueArgs
                        {
                            Value = "string",
                            Type = "string",
                        },
                        FailTestOnCannotLocate = false,
                    },
                    Email = "string",
                    File = "string",
                    Files = "string",
                    Modifiers = new[]
                    {
                        "string",
                    },
                    PlayingTabId = "string",
                    Request = "string",
                    SubtestPublicId = "string",
                    Value = "string",
                    Variable = new Datadog.Inputs.SyntheticsTestBrowserStepParamsVariableArgs
                    {
                        Example = "string",
                        Name = "string",
                    },
                    WithClick = false,
                    X = 0,
                    Y = 0,
                },
                Type = "string",
                AllowFailure = false,
                ForceElementUpdate = false,
                IsCritical = false,
                NoScreenshot = false,
                Timeout = 0,
            },
        },
        Subtype = "string",
        Tags = new[]
        {
            "string",
        },
        Assertions = new[]
        {
            new Datadog.Inputs.SyntheticsTestAssertionArgs
            {
                Operator = "string",
                Type = "string",
                Property = "string",
                Target = "string",
                Targetjsonpath = new Datadog.Inputs.SyntheticsTestAssertionTargetjsonpathArgs
                {
                    Jsonpath = "string",
                    Operator = "string",
                    Targetvalue = "string",
                },
                Targetxpath = new Datadog.Inputs.SyntheticsTestAssertionTargetxpathArgs
                {
                    Operator = "string",
                    Xpath = "string",
                    Targetvalue = "string",
                },
                TimingsScope = "string",
            },
        },
    });
    
    example, err := datadog.NewSyntheticsTest(ctx, "syntheticsTestResource", &datadog.SyntheticsTestArgs{
    	Locations: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Type:   pulumi.String("string"),
    	Status: pulumi.String("string"),
    	Name:   pulumi.String("string"),
    	RequestBasicauth: &datadog.SyntheticsTestRequestBasicauthArgs{
    		AccessKey:              pulumi.String("string"),
    		AccessTokenUrl:         pulumi.String("string"),
    		Audience:               pulumi.String("string"),
    		ClientId:               pulumi.String("string"),
    		ClientSecret:           pulumi.String("string"),
    		Domain:                 pulumi.String("string"),
    		Password:               pulumi.String("string"),
    		Region:                 pulumi.String("string"),
    		Resource:               pulumi.String("string"),
    		Scope:                  pulumi.String("string"),
    		SecretKey:              pulumi.String("string"),
    		ServiceName:            pulumi.String("string"),
    		SessionToken:           pulumi.String("string"),
    		TokenApiAuthentication: pulumi.String("string"),
    		Type:                   pulumi.String("string"),
    		Username:               pulumi.String("string"),
    		Workstation:            pulumi.String("string"),
    	},
    	RequestHeaders: pulumi.Map{
    		"string": pulumi.Any("any"),
    	},
    	ConfigVariables: datadog.SyntheticsTestConfigVariableArray{
    		&datadog.SyntheticsTestConfigVariableArgs{
    			Name:    pulumi.String("string"),
    			Type:    pulumi.String("string"),
    			Example: pulumi.String("string"),
    			Id:      pulumi.String("string"),
    			Pattern: pulumi.String("string"),
    			Secure:  pulumi.Bool(false),
    		},
    	},
    	Message: pulumi.String("string"),
    	BrowserVariables: datadog.SyntheticsTestBrowserVariableArray{
    		&datadog.SyntheticsTestBrowserVariableArgs{
    			Name:    pulumi.String("string"),
    			Type:    pulumi.String("string"),
    			Example: pulumi.String("string"),
    			Id:      pulumi.String("string"),
    			Pattern: pulumi.String("string"),
    			Secure:  pulumi.Bool(false),
    		},
    	},
    	OptionsList: &datadog.SyntheticsTestOptionsListArgs{
    		TickEvery:          pulumi.Int(0),
    		MinFailureDuration: pulumi.Int(0),
    		RumSettings: &datadog.SyntheticsTestOptionsListRumSettingsArgs{
    			IsEnabled:     pulumi.Bool(false),
    			ApplicationId: pulumi.String("string"),
    			ClientTokenId: pulumi.Int(0),
    		},
    		Ci: &datadog.SyntheticsTestOptionsListCiArgs{
    			ExecutionRule: pulumi.String("string"),
    		},
    		DisableCors:                  pulumi.Bool(false),
    		DisableCsp:                   pulumi.Bool(false),
    		FollowRedirects:              pulumi.Bool(false),
    		HttpVersion:                  pulumi.String("string"),
    		MinLocationFailed:            pulumi.Int(0),
    		AllowInsecure:                pulumi.Bool(false),
    		CheckCertificateRevocation:   pulumi.Bool(false),
    		IgnoreServerCertificateError: pulumi.Bool(false),
    		MonitorName:                  pulumi.String("string"),
    		MonitorOptions: &datadog.SyntheticsTestOptionsListMonitorOptionsArgs{
    			RenotifyInterval: pulumi.Int(0),
    		},
    		MonitorPriority: pulumi.Int(0),
    		NoScreenshot:    pulumi.Bool(false),
    		RestrictedRoles: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		Retry: &datadog.SyntheticsTestOptionsListRetryArgs{
    			Count:    pulumi.Int(0),
    			Interval: pulumi.Int(0),
    		},
    		AcceptSelfSigned: pulumi.Bool(false),
    		Scheduling: &datadog.SyntheticsTestOptionsListSchedulingArgs{
    			Timeframes: datadog.SyntheticsTestOptionsListSchedulingTimeframeArray{
    				&datadog.SyntheticsTestOptionsListSchedulingTimeframeArgs{
    					Day:  pulumi.Int(0),
    					From: pulumi.String("string"),
    					To:   pulumi.String("string"),
    				},
    			},
    			Timezone: pulumi.String("string"),
    		},
    		InitialNavigationTimeout: pulumi.Int(0),
    	},
    	ApiSteps: datadog.SyntheticsTestApiStepArray{
    		&datadog.SyntheticsTestApiStepArgs{
    			Name: pulumi.String("string"),
    			RequestClientCertificate: &datadog.SyntheticsTestApiStepRequestClientCertificateArgs{
    				Cert: &datadog.SyntheticsTestApiStepRequestClientCertificateCertArgs{
    					Content:  pulumi.String("string"),
    					Filename: pulumi.String("string"),
    				},
    				Key: &datadog.SyntheticsTestApiStepRequestClientCertificateKeyArgs{
    					Content:  pulumi.String("string"),
    					Filename: pulumi.String("string"),
    				},
    			},
    			ExtractedValues: datadog.SyntheticsTestApiStepExtractedValueArray{
    				&datadog.SyntheticsTestApiStepExtractedValueArgs{
    					Name: pulumi.String("string"),
    					Parser: &datadog.SyntheticsTestApiStepExtractedValueParserArgs{
    						Type:  pulumi.String("string"),
    						Value: pulumi.String("string"),
    					},
    					Type:   pulumi.String("string"),
    					Field:  pulumi.String("string"),
    					Secure: pulumi.Bool(false),
    				},
    			},
    			IsCritical: pulumi.Bool(false),
    			Assertions: datadog.SyntheticsTestApiStepAssertionArray{
    				&datadog.SyntheticsTestApiStepAssertionArgs{
    					Operator: pulumi.String("string"),
    					Type:     pulumi.String("string"),
    					Property: pulumi.String("string"),
    					Target:   pulumi.String("string"),
    					Targetjsonpath: &datadog.SyntheticsTestApiStepAssertionTargetjsonpathArgs{
    						Jsonpath:    pulumi.String("string"),
    						Operator:    pulumi.String("string"),
    						Targetvalue: pulumi.String("string"),
    					},
    					Targetxpath: &datadog.SyntheticsTestApiStepAssertionTargetxpathArgs{
    						Operator:    pulumi.String("string"),
    						Xpath:       pulumi.String("string"),
    						Targetvalue: pulumi.String("string"),
    					},
    					TimingsScope: pulumi.String("string"),
    				},
    			},
    			RequestBasicauth: &datadog.SyntheticsTestApiStepRequestBasicauthArgs{
    				AccessKey:              pulumi.String("string"),
    				AccessTokenUrl:         pulumi.String("string"),
    				Audience:               pulumi.String("string"),
    				ClientId:               pulumi.String("string"),
    				ClientSecret:           pulumi.String("string"),
    				Domain:                 pulumi.String("string"),
    				Password:               pulumi.String("string"),
    				Region:                 pulumi.String("string"),
    				Resource:               pulumi.String("string"),
    				Scope:                  pulumi.String("string"),
    				SecretKey:              pulumi.String("string"),
    				ServiceName:            pulumi.String("string"),
    				SessionToken:           pulumi.String("string"),
    				TokenApiAuthentication: pulumi.String("string"),
    				Type:                   pulumi.String("string"),
    				Username:               pulumi.String("string"),
    				Workstation:            pulumi.String("string"),
    			},
    			AllowFailure: pulumi.Bool(false),
    			RequestDefinition: &datadog.SyntheticsTestApiStepRequestDefinitionArgs{
    				AllowInsecure: pulumi.Bool(false),
    				Body:          pulumi.String("string"),
    				BodyType:      pulumi.String("string"),
    				CallType:      pulumi.String("string"),
    				CertificateDomains: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				DnsServer:            pulumi.String("string"),
    				DnsServerPort:        pulumi.Int(0),
    				FollowRedirects:      pulumi.Bool(false),
    				Host:                 pulumi.String("string"),
    				HttpVersion:          pulumi.String("string"),
    				Message:              pulumi.String("string"),
    				Method:               pulumi.String("string"),
    				NoSavingResponseBody: pulumi.Bool(false),
    				NumberOfPackets:      pulumi.Int(0),
    				PersistCookies:       pulumi.Bool(false),
    				PlainProtoFile:       pulumi.String("string"),
    				Port:                 pulumi.Int(0),
    				Servername:           pulumi.String("string"),
    				Service:              pulumi.String("string"),
    				ShouldTrackHops:      pulumi.Bool(false),
    				Timeout:              pulumi.Int(0),
    				Url:                  pulumi.String("string"),
    			},
    			RequestHeaders: pulumi.Map{
    				"string": pulumi.Any("any"),
    			},
    			RequestProxy: &datadog.SyntheticsTestApiStepRequestProxyArgs{
    				Url: pulumi.String("string"),
    				Headers: pulumi.Map{
    					"string": pulumi.Any("any"),
    				},
    			},
    			RequestQuery: pulumi.Map{
    				"string": pulumi.Any("any"),
    			},
    			Retry: &datadog.SyntheticsTestApiStepRetryArgs{
    				Count:    pulumi.Int(0),
    				Interval: pulumi.Int(0),
    			},
    			Subtype: pulumi.String("string"),
    		},
    	},
    	RequestClientCertificate: &datadog.SyntheticsTestRequestClientCertificateArgs{
    		Cert: &datadog.SyntheticsTestRequestClientCertificateCertArgs{
    			Content:  pulumi.String("string"),
    			Filename: pulumi.String("string"),
    		},
    		Key: &datadog.SyntheticsTestRequestClientCertificateKeyArgs{
    			Content:  pulumi.String("string"),
    			Filename: pulumi.String("string"),
    		},
    	},
    	RequestDefinition: &datadog.SyntheticsTestRequestDefinitionArgs{
    		Body:     pulumi.String("string"),
    		BodyType: pulumi.String("string"),
    		CallType: pulumi.String("string"),
    		CertificateDomains: pulumi.StringArray{
    			pulumi.String("string"),
    		},
    		DnsServer:            pulumi.String("string"),
    		DnsServerPort:        pulumi.Int(0),
    		Host:                 pulumi.String("string"),
    		HttpVersion:          pulumi.String("string"),
    		Message:              pulumi.String("string"),
    		Method:               pulumi.String("string"),
    		NoSavingResponseBody: pulumi.Bool(false),
    		NumberOfPackets:      pulumi.Int(0),
    		PersistCookies:       pulumi.Bool(false),
    		PlainProtoFile:       pulumi.String("string"),
    		Port:                 pulumi.Int(0),
    		Servername:           pulumi.String("string"),
    		Service:              pulumi.String("string"),
    		ShouldTrackHops:      pulumi.Bool(false),
    		Timeout:              pulumi.Int(0),
    		Url:                  pulumi.String("string"),
    	},
    	DeviceIds: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	RequestMetadata: pulumi.Map{
    		"string": pulumi.Any("any"),
    	},
    	RequestProxy: &datadog.SyntheticsTestRequestProxyArgs{
    		Url: pulumi.String("string"),
    		Headers: pulumi.Map{
    			"string": pulumi.Any("any"),
    		},
    	},
    	RequestQuery: pulumi.Map{
    		"string": pulumi.Any("any"),
    	},
    	SetCookie: pulumi.String("string"),
    	BrowserSteps: datadog.SyntheticsTestBrowserStepArray{
    		&datadog.SyntheticsTestBrowserStepArgs{
    			Name: pulumi.String("string"),
    			Params: &datadog.SyntheticsTestBrowserStepParamsArgs{
    				Attribute: pulumi.String("string"),
    				Check:     pulumi.String("string"),
    				ClickType: pulumi.String("string"),
    				Code:      pulumi.String("string"),
    				Delay:     pulumi.Int(0),
    				Element:   pulumi.String("string"),
    				ElementUserLocator: &datadog.SyntheticsTestBrowserStepParamsElementUserLocatorArgs{
    					Value: &datadog.SyntheticsTestBrowserStepParamsElementUserLocatorValueArgs{
    						Value: pulumi.String("string"),
    						Type:  pulumi.String("string"),
    					},
    					FailTestOnCannotLocate: pulumi.Bool(false),
    				},
    				Email: pulumi.String("string"),
    				File:  pulumi.String("string"),
    				Files: pulumi.String("string"),
    				Modifiers: pulumi.StringArray{
    					pulumi.String("string"),
    				},
    				PlayingTabId:    pulumi.String("string"),
    				Request:         pulumi.String("string"),
    				SubtestPublicId: pulumi.String("string"),
    				Value:           pulumi.String("string"),
    				Variable: &datadog.SyntheticsTestBrowserStepParamsVariableArgs{
    					Example: pulumi.String("string"),
    					Name:    pulumi.String("string"),
    				},
    				WithClick: pulumi.Bool(false),
    				X:         pulumi.Int(0),
    				Y:         pulumi.Int(0),
    			},
    			Type:               pulumi.String("string"),
    			AllowFailure:       pulumi.Bool(false),
    			ForceElementUpdate: pulumi.Bool(false),
    			IsCritical:         pulumi.Bool(false),
    			NoScreenshot:       pulumi.Bool(false),
    			Timeout:            pulumi.Int(0),
    		},
    	},
    	Subtype: pulumi.String("string"),
    	Tags: pulumi.StringArray{
    		pulumi.String("string"),
    	},
    	Assertions: datadog.SyntheticsTestAssertionArray{
    		&datadog.SyntheticsTestAssertionArgs{
    			Operator: pulumi.String("string"),
    			Type:     pulumi.String("string"),
    			Property: pulumi.String("string"),
    			Target:   pulumi.String("string"),
    			Targetjsonpath: &datadog.SyntheticsTestAssertionTargetjsonpathArgs{
    				Jsonpath:    pulumi.String("string"),
    				Operator:    pulumi.String("string"),
    				Targetvalue: pulumi.String("string"),
    			},
    			Targetxpath: &datadog.SyntheticsTestAssertionTargetxpathArgs{
    				Operator:    pulumi.String("string"),
    				Xpath:       pulumi.String("string"),
    				Targetvalue: pulumi.String("string"),
    			},
    			TimingsScope: pulumi.String("string"),
    		},
    	},
    })
    
    var syntheticsTestResource = new SyntheticsTest("syntheticsTestResource", SyntheticsTestArgs.builder()        
        .locations("string")
        .type("string")
        .status("string")
        .name("string")
        .requestBasicauth(SyntheticsTestRequestBasicauthArgs.builder()
            .accessKey("string")
            .accessTokenUrl("string")
            .audience("string")
            .clientId("string")
            .clientSecret("string")
            .domain("string")
            .password("string")
            .region("string")
            .resource("string")
            .scope("string")
            .secretKey("string")
            .serviceName("string")
            .sessionToken("string")
            .tokenApiAuthentication("string")
            .type("string")
            .username("string")
            .workstation("string")
            .build())
        .requestHeaders(Map.of("string", "any"))
        .configVariables(SyntheticsTestConfigVariableArgs.builder()
            .name("string")
            .type("string")
            .example("string")
            .id("string")
            .pattern("string")
            .secure(false)
            .build())
        .message("string")
        .browserVariables(SyntheticsTestBrowserVariableArgs.builder()
            .name("string")
            .type("string")
            .example("string")
            .id("string")
            .pattern("string")
            .secure(false)
            .build())
        .optionsList(SyntheticsTestOptionsListArgs.builder()
            .tickEvery(0)
            .minFailureDuration(0)
            .rumSettings(SyntheticsTestOptionsListRumSettingsArgs.builder()
                .isEnabled(false)
                .applicationId("string")
                .clientTokenId(0)
                .build())
            .ci(SyntheticsTestOptionsListCiArgs.builder()
                .executionRule("string")
                .build())
            .disableCors(false)
            .disableCsp(false)
            .followRedirects(false)
            .httpVersion("string")
            .minLocationFailed(0)
            .allowInsecure(false)
            .checkCertificateRevocation(false)
            .ignoreServerCertificateError(false)
            .monitorName("string")
            .monitorOptions(SyntheticsTestOptionsListMonitorOptionsArgs.builder()
                .renotifyInterval(0)
                .build())
            .monitorPriority(0)
            .noScreenshot(false)
            .restrictedRoles("string")
            .retry(SyntheticsTestOptionsListRetryArgs.builder()
                .count(0)
                .interval(0)
                .build())
            .acceptSelfSigned(false)
            .scheduling(SyntheticsTestOptionsListSchedulingArgs.builder()
                .timeframes(SyntheticsTestOptionsListSchedulingTimeframeArgs.builder()
                    .day(0)
                    .from("string")
                    .to("string")
                    .build())
                .timezone("string")
                .build())
            .initialNavigationTimeout(0)
            .build())
        .apiSteps(SyntheticsTestApiStepArgs.builder()
            .name("string")
            .requestClientCertificate(SyntheticsTestApiStepRequestClientCertificateArgs.builder()
                .cert(SyntheticsTestApiStepRequestClientCertificateCertArgs.builder()
                    .content("string")
                    .filename("string")
                    .build())
                .key(SyntheticsTestApiStepRequestClientCertificateKeyArgs.builder()
                    .content("string")
                    .filename("string")
                    .build())
                .build())
            .extractedValues(SyntheticsTestApiStepExtractedValueArgs.builder()
                .name("string")
                .parser(SyntheticsTestApiStepExtractedValueParserArgs.builder()
                    .type("string")
                    .value("string")
                    .build())
                .type("string")
                .field("string")
                .secure(false)
                .build())
            .isCritical(false)
            .assertions(SyntheticsTestApiStepAssertionArgs.builder()
                .operator("string")
                .type("string")
                .property("string")
                .target("string")
                .targetjsonpath(SyntheticsTestApiStepAssertionTargetjsonpathArgs.builder()
                    .jsonpath("string")
                    .operator("string")
                    .targetvalue("string")
                    .build())
                .targetxpath(SyntheticsTestApiStepAssertionTargetxpathArgs.builder()
                    .operator("string")
                    .xpath("string")
                    .targetvalue("string")
                    .build())
                .timingsScope("string")
                .build())
            .requestBasicauth(SyntheticsTestApiStepRequestBasicauthArgs.builder()
                .accessKey("string")
                .accessTokenUrl("string")
                .audience("string")
                .clientId("string")
                .clientSecret("string")
                .domain("string")
                .password("string")
                .region("string")
                .resource("string")
                .scope("string")
                .secretKey("string")
                .serviceName("string")
                .sessionToken("string")
                .tokenApiAuthentication("string")
                .type("string")
                .username("string")
                .workstation("string")
                .build())
            .allowFailure(false)
            .requestDefinition(SyntheticsTestApiStepRequestDefinitionArgs.builder()
                .allowInsecure(false)
                .body("string")
                .bodyType("string")
                .callType("string")
                .certificateDomains("string")
                .dnsServer("string")
                .dnsServerPort(0)
                .followRedirects(false)
                .host("string")
                .httpVersion("string")
                .message("string")
                .method("string")
                .noSavingResponseBody(false)
                .numberOfPackets(0)
                .persistCookies(false)
                .plainProtoFile("string")
                .port(0)
                .servername("string")
                .service("string")
                .shouldTrackHops(false)
                .timeout(0)
                .url("string")
                .build())
            .requestHeaders(Map.of("string", "any"))
            .requestProxy(SyntheticsTestApiStepRequestProxyArgs.builder()
                .url("string")
                .headers(Map.of("string", "any"))
                .build())
            .requestQuery(Map.of("string", "any"))
            .retry(SyntheticsTestApiStepRetryArgs.builder()
                .count(0)
                .interval(0)
                .build())
            .subtype("string")
            .build())
        .requestClientCertificate(SyntheticsTestRequestClientCertificateArgs.builder()
            .cert(SyntheticsTestRequestClientCertificateCertArgs.builder()
                .content("string")
                .filename("string")
                .build())
            .key(SyntheticsTestRequestClientCertificateKeyArgs.builder()
                .content("string")
                .filename("string")
                .build())
            .build())
        .requestDefinition(SyntheticsTestRequestDefinitionArgs.builder()
            .body("string")
            .bodyType("string")
            .callType("string")
            .certificateDomains("string")
            .dnsServer("string")
            .dnsServerPort(0)
            .host("string")
            .httpVersion("string")
            .message("string")
            .method("string")
            .noSavingResponseBody(false)
            .numberOfPackets(0)
            .persistCookies(false)
            .plainProtoFile("string")
            .port(0)
            .servername("string")
            .service("string")
            .shouldTrackHops(false)
            .timeout(0)
            .url("string")
            .build())
        .deviceIds("string")
        .requestMetadata(Map.of("string", "any"))
        .requestProxy(SyntheticsTestRequestProxyArgs.builder()
            .url("string")
            .headers(Map.of("string", "any"))
            .build())
        .requestQuery(Map.of("string", "any"))
        .setCookie("string")
        .browserSteps(SyntheticsTestBrowserStepArgs.builder()
            .name("string")
            .params(SyntheticsTestBrowserStepParamsArgs.builder()
                .attribute("string")
                .check("string")
                .clickType("string")
                .code("string")
                .delay(0)
                .element("string")
                .elementUserLocator(SyntheticsTestBrowserStepParamsElementUserLocatorArgs.builder()
                    .value(SyntheticsTestBrowserStepParamsElementUserLocatorValueArgs.builder()
                        .value("string")
                        .type("string")
                        .build())
                    .failTestOnCannotLocate(false)
                    .build())
                .email("string")
                .file("string")
                .files("string")
                .modifiers("string")
                .playingTabId("string")
                .request("string")
                .subtestPublicId("string")
                .value("string")
                .variable(SyntheticsTestBrowserStepParamsVariableArgs.builder()
                    .example("string")
                    .name("string")
                    .build())
                .withClick(false)
                .x(0)
                .y(0)
                .build())
            .type("string")
            .allowFailure(false)
            .forceElementUpdate(false)
            .isCritical(false)
            .noScreenshot(false)
            .timeout(0)
            .build())
        .subtype("string")
        .tags("string")
        .assertions(SyntheticsTestAssertionArgs.builder()
            .operator("string")
            .type("string")
            .property("string")
            .target("string")
            .targetjsonpath(SyntheticsTestAssertionTargetjsonpathArgs.builder()
                .jsonpath("string")
                .operator("string")
                .targetvalue("string")
                .build())
            .targetxpath(SyntheticsTestAssertionTargetxpathArgs.builder()
                .operator("string")
                .xpath("string")
                .targetvalue("string")
                .build())
            .timingsScope("string")
            .build())
        .build());
    
    synthetics_test_resource = datadog.SyntheticsTest("syntheticsTestResource",
        locations=["string"],
        type="string",
        status="string",
        name="string",
        request_basicauth=datadog.SyntheticsTestRequestBasicauthArgs(
            access_key="string",
            access_token_url="string",
            audience="string",
            client_id="string",
            client_secret="string",
            domain="string",
            password="string",
            region="string",
            resource="string",
            scope="string",
            secret_key="string",
            service_name="string",
            session_token="string",
            token_api_authentication="string",
            type="string",
            username="string",
            workstation="string",
        ),
        request_headers={
            "string": "any",
        },
        config_variables=[datadog.SyntheticsTestConfigVariableArgs(
            name="string",
            type="string",
            example="string",
            id="string",
            pattern="string",
            secure=False,
        )],
        message="string",
        browser_variables=[datadog.SyntheticsTestBrowserVariableArgs(
            name="string",
            type="string",
            example="string",
            id="string",
            pattern="string",
            secure=False,
        )],
        options_list=datadog.SyntheticsTestOptionsListArgs(
            tick_every=0,
            min_failure_duration=0,
            rum_settings=datadog.SyntheticsTestOptionsListRumSettingsArgs(
                is_enabled=False,
                application_id="string",
                client_token_id=0,
            ),
            ci=datadog.SyntheticsTestOptionsListCiArgs(
                execution_rule="string",
            ),
            disable_cors=False,
            disable_csp=False,
            follow_redirects=False,
            http_version="string",
            min_location_failed=0,
            allow_insecure=False,
            check_certificate_revocation=False,
            ignore_server_certificate_error=False,
            monitor_name="string",
            monitor_options=datadog.SyntheticsTestOptionsListMonitorOptionsArgs(
                renotify_interval=0,
            ),
            monitor_priority=0,
            no_screenshot=False,
            restricted_roles=["string"],
            retry=datadog.SyntheticsTestOptionsListRetryArgs(
                count=0,
                interval=0,
            ),
            accept_self_signed=False,
            scheduling=datadog.SyntheticsTestOptionsListSchedulingArgs(
                timeframes=[datadog.SyntheticsTestOptionsListSchedulingTimeframeArgs(
                    day=0,
                    from_="string",
                    to="string",
                )],
                timezone="string",
            ),
            initial_navigation_timeout=0,
        ),
        api_steps=[datadog.SyntheticsTestApiStepArgs(
            name="string",
            request_client_certificate=datadog.SyntheticsTestApiStepRequestClientCertificateArgs(
                cert=datadog.SyntheticsTestApiStepRequestClientCertificateCertArgs(
                    content="string",
                    filename="string",
                ),
                key=datadog.SyntheticsTestApiStepRequestClientCertificateKeyArgs(
                    content="string",
                    filename="string",
                ),
            ),
            extracted_values=[datadog.SyntheticsTestApiStepExtractedValueArgs(
                name="string",
                parser=datadog.SyntheticsTestApiStepExtractedValueParserArgs(
                    type="string",
                    value="string",
                ),
                type="string",
                field="string",
                secure=False,
            )],
            is_critical=False,
            assertions=[datadog.SyntheticsTestApiStepAssertionArgs(
                operator="string",
                type="string",
                property="string",
                target="string",
                targetjsonpath=datadog.SyntheticsTestApiStepAssertionTargetjsonpathArgs(
                    jsonpath="string",
                    operator="string",
                    targetvalue="string",
                ),
                targetxpath=datadog.SyntheticsTestApiStepAssertionTargetxpathArgs(
                    operator="string",
                    xpath="string",
                    targetvalue="string",
                ),
                timings_scope="string",
            )],
            request_basicauth=datadog.SyntheticsTestApiStepRequestBasicauthArgs(
                access_key="string",
                access_token_url="string",
                audience="string",
                client_id="string",
                client_secret="string",
                domain="string",
                password="string",
                region="string",
                resource="string",
                scope="string",
                secret_key="string",
                service_name="string",
                session_token="string",
                token_api_authentication="string",
                type="string",
                username="string",
                workstation="string",
            ),
            allow_failure=False,
            request_definition=datadog.SyntheticsTestApiStepRequestDefinitionArgs(
                allow_insecure=False,
                body="string",
                body_type="string",
                call_type="string",
                certificate_domains=["string"],
                dns_server="string",
                dns_server_port=0,
                follow_redirects=False,
                host="string",
                http_version="string",
                message="string",
                method="string",
                no_saving_response_body=False,
                number_of_packets=0,
                persist_cookies=False,
                plain_proto_file="string",
                port=0,
                servername="string",
                service="string",
                should_track_hops=False,
                timeout=0,
                url="string",
            ),
            request_headers={
                "string": "any",
            },
            request_proxy=datadog.SyntheticsTestApiStepRequestProxyArgs(
                url="string",
                headers={
                    "string": "any",
                },
            ),
            request_query={
                "string": "any",
            },
            retry=datadog.SyntheticsTestApiStepRetryArgs(
                count=0,
                interval=0,
            ),
            subtype="string",
        )],
        request_client_certificate=datadog.SyntheticsTestRequestClientCertificateArgs(
            cert=datadog.SyntheticsTestRequestClientCertificateCertArgs(
                content="string",
                filename="string",
            ),
            key=datadog.SyntheticsTestRequestClientCertificateKeyArgs(
                content="string",
                filename="string",
            ),
        ),
        request_definition=datadog.SyntheticsTestRequestDefinitionArgs(
            body="string",
            body_type="string",
            call_type="string",
            certificate_domains=["string"],
            dns_server="string",
            dns_server_port=0,
            host="string",
            http_version="string",
            message="string",
            method="string",
            no_saving_response_body=False,
            number_of_packets=0,
            persist_cookies=False,
            plain_proto_file="string",
            port=0,
            servername="string",
            service="string",
            should_track_hops=False,
            timeout=0,
            url="string",
        ),
        device_ids=["string"],
        request_metadata={
            "string": "any",
        },
        request_proxy=datadog.SyntheticsTestRequestProxyArgs(
            url="string",
            headers={
                "string": "any",
            },
        ),
        request_query={
            "string": "any",
        },
        set_cookie="string",
        browser_steps=[datadog.SyntheticsTestBrowserStepArgs(
            name="string",
            params=datadog.SyntheticsTestBrowserStepParamsArgs(
                attribute="string",
                check="string",
                click_type="string",
                code="string",
                delay=0,
                element="string",
                element_user_locator=datadog.SyntheticsTestBrowserStepParamsElementUserLocatorArgs(
                    value=datadog.SyntheticsTestBrowserStepParamsElementUserLocatorValueArgs(
                        value="string",
                        type="string",
                    ),
                    fail_test_on_cannot_locate=False,
                ),
                email="string",
                file="string",
                files="string",
                modifiers=["string"],
                playing_tab_id="string",
                request="string",
                subtest_public_id="string",
                value="string",
                variable=datadog.SyntheticsTestBrowserStepParamsVariableArgs(
                    example="string",
                    name="string",
                ),
                with_click=False,
                x=0,
                y=0,
            ),
            type="string",
            allow_failure=False,
            force_element_update=False,
            is_critical=False,
            no_screenshot=False,
            timeout=0,
        )],
        subtype="string",
        tags=["string"],
        assertions=[datadog.SyntheticsTestAssertionArgs(
            operator="string",
            type="string",
            property="string",
            target="string",
            targetjsonpath=datadog.SyntheticsTestAssertionTargetjsonpathArgs(
                jsonpath="string",
                operator="string",
                targetvalue="string",
            ),
            targetxpath=datadog.SyntheticsTestAssertionTargetxpathArgs(
                operator="string",
                xpath="string",
                targetvalue="string",
            ),
            timings_scope="string",
        )])
    
    const syntheticsTestResource = new datadog.SyntheticsTest("syntheticsTestResource", {
        locations: ["string"],
        type: "string",
        status: "string",
        name: "string",
        requestBasicauth: {
            accessKey: "string",
            accessTokenUrl: "string",
            audience: "string",
            clientId: "string",
            clientSecret: "string",
            domain: "string",
            password: "string",
            region: "string",
            resource: "string",
            scope: "string",
            secretKey: "string",
            serviceName: "string",
            sessionToken: "string",
            tokenApiAuthentication: "string",
            type: "string",
            username: "string",
            workstation: "string",
        },
        requestHeaders: {
            string: "any",
        },
        configVariables: [{
            name: "string",
            type: "string",
            example: "string",
            id: "string",
            pattern: "string",
            secure: false,
        }],
        message: "string",
        browserVariables: [{
            name: "string",
            type: "string",
            example: "string",
            id: "string",
            pattern: "string",
            secure: false,
        }],
        optionsList: {
            tickEvery: 0,
            minFailureDuration: 0,
            rumSettings: {
                isEnabled: false,
                applicationId: "string",
                clientTokenId: 0,
            },
            ci: {
                executionRule: "string",
            },
            disableCors: false,
            disableCsp: false,
            followRedirects: false,
            httpVersion: "string",
            minLocationFailed: 0,
            allowInsecure: false,
            checkCertificateRevocation: false,
            ignoreServerCertificateError: false,
            monitorName: "string",
            monitorOptions: {
                renotifyInterval: 0,
            },
            monitorPriority: 0,
            noScreenshot: false,
            restrictedRoles: ["string"],
            retry: {
                count: 0,
                interval: 0,
            },
            acceptSelfSigned: false,
            scheduling: {
                timeframes: [{
                    day: 0,
                    from: "string",
                    to: "string",
                }],
                timezone: "string",
            },
            initialNavigationTimeout: 0,
        },
        apiSteps: [{
            name: "string",
            requestClientCertificate: {
                cert: {
                    content: "string",
                    filename: "string",
                },
                key: {
                    content: "string",
                    filename: "string",
                },
            },
            extractedValues: [{
                name: "string",
                parser: {
                    type: "string",
                    value: "string",
                },
                type: "string",
                field: "string",
                secure: false,
            }],
            isCritical: false,
            assertions: [{
                operator: "string",
                type: "string",
                property: "string",
                target: "string",
                targetjsonpath: {
                    jsonpath: "string",
                    operator: "string",
                    targetvalue: "string",
                },
                targetxpath: {
                    operator: "string",
                    xpath: "string",
                    targetvalue: "string",
                },
                timingsScope: "string",
            }],
            requestBasicauth: {
                accessKey: "string",
                accessTokenUrl: "string",
                audience: "string",
                clientId: "string",
                clientSecret: "string",
                domain: "string",
                password: "string",
                region: "string",
                resource: "string",
                scope: "string",
                secretKey: "string",
                serviceName: "string",
                sessionToken: "string",
                tokenApiAuthentication: "string",
                type: "string",
                username: "string",
                workstation: "string",
            },
            allowFailure: false,
            requestDefinition: {
                allowInsecure: false,
                body: "string",
                bodyType: "string",
                callType: "string",
                certificateDomains: ["string"],
                dnsServer: "string",
                dnsServerPort: 0,
                followRedirects: false,
                host: "string",
                httpVersion: "string",
                message: "string",
                method: "string",
                noSavingResponseBody: false,
                numberOfPackets: 0,
                persistCookies: false,
                plainProtoFile: "string",
                port: 0,
                servername: "string",
                service: "string",
                shouldTrackHops: false,
                timeout: 0,
                url: "string",
            },
            requestHeaders: {
                string: "any",
            },
            requestProxy: {
                url: "string",
                headers: {
                    string: "any",
                },
            },
            requestQuery: {
                string: "any",
            },
            retry: {
                count: 0,
                interval: 0,
            },
            subtype: "string",
        }],
        requestClientCertificate: {
            cert: {
                content: "string",
                filename: "string",
            },
            key: {
                content: "string",
                filename: "string",
            },
        },
        requestDefinition: {
            body: "string",
            bodyType: "string",
            callType: "string",
            certificateDomains: ["string"],
            dnsServer: "string",
            dnsServerPort: 0,
            host: "string",
            httpVersion: "string",
            message: "string",
            method: "string",
            noSavingResponseBody: false,
            numberOfPackets: 0,
            persistCookies: false,
            plainProtoFile: "string",
            port: 0,
            servername: "string",
            service: "string",
            shouldTrackHops: false,
            timeout: 0,
            url: "string",
        },
        deviceIds: ["string"],
        requestMetadata: {
            string: "any",
        },
        requestProxy: {
            url: "string",
            headers: {
                string: "any",
            },
        },
        requestQuery: {
            string: "any",
        },
        setCookie: "string",
        browserSteps: [{
            name: "string",
            params: {
                attribute: "string",
                check: "string",
                clickType: "string",
                code: "string",
                delay: 0,
                element: "string",
                elementUserLocator: {
                    value: {
                        value: "string",
                        type: "string",
                    },
                    failTestOnCannotLocate: false,
                },
                email: "string",
                file: "string",
                files: "string",
                modifiers: ["string"],
                playingTabId: "string",
                request: "string",
                subtestPublicId: "string",
                value: "string",
                variable: {
                    example: "string",
                    name: "string",
                },
                withClick: false,
                x: 0,
                y: 0,
            },
            type: "string",
            allowFailure: false,
            forceElementUpdate: false,
            isCritical: false,
            noScreenshot: false,
            timeout: 0,
        }],
        subtype: "string",
        tags: ["string"],
        assertions: [{
            operator: "string",
            type: "string",
            property: "string",
            target: "string",
            targetjsonpath: {
                jsonpath: "string",
                operator: "string",
                targetvalue: "string",
            },
            targetxpath: {
                operator: "string",
                xpath: "string",
                targetvalue: "string",
            },
            timingsScope: "string",
        }],
    });
    
    type: datadog:SyntheticsTest
    properties:
        apiSteps:
            - allowFailure: false
              assertions:
                - operator: string
                  property: string
                  target: string
                  targetjsonpath:
                    jsonpath: string
                    operator: string
                    targetvalue: string
                  targetxpath:
                    operator: string
                    targetvalue: string
                    xpath: string
                  timingsScope: string
                  type: string
              extractedValues:
                - field: string
                  name: string
                  parser:
                    type: string
                    value: string
                  secure: false
                  type: string
              isCritical: false
              name: string
              requestBasicauth:
                accessKey: string
                accessTokenUrl: string
                audience: string
                clientId: string
                clientSecret: string
                domain: string
                password: string
                region: string
                resource: string
                scope: string
                secretKey: string
                serviceName: string
                sessionToken: string
                tokenApiAuthentication: string
                type: string
                username: string
                workstation: string
              requestClientCertificate:
                cert:
                    content: string
                    filename: string
                key:
                    content: string
                    filename: string
              requestDefinition:
                allowInsecure: false
                body: string
                bodyType: string
                callType: string
                certificateDomains:
                    - string
                dnsServer: string
                dnsServerPort: 0
                followRedirects: false
                host: string
                httpVersion: string
                message: string
                method: string
                noSavingResponseBody: false
                numberOfPackets: 0
                persistCookies: false
                plainProtoFile: string
                port: 0
                servername: string
                service: string
                shouldTrackHops: false
                timeout: 0
                url: string
              requestHeaders:
                string: any
              requestProxy:
                headers:
                    string: any
                url: string
              requestQuery:
                string: any
              retry:
                count: 0
                interval: 0
              subtype: string
        assertions:
            - operator: string
              property: string
              target: string
              targetjsonpath:
                jsonpath: string
                operator: string
                targetvalue: string
              targetxpath:
                operator: string
                targetvalue: string
                xpath: string
              timingsScope: string
              type: string
        browserSteps:
            - allowFailure: false
              forceElementUpdate: false
              isCritical: false
              name: string
              noScreenshot: false
              params:
                attribute: string
                check: string
                clickType: string
                code: string
                delay: 0
                element: string
                elementUserLocator:
                    failTestOnCannotLocate: false
                    value:
                        type: string
                        value: string
                email: string
                file: string
                files: string
                modifiers:
                    - string
                playingTabId: string
                request: string
                subtestPublicId: string
                value: string
                variable:
                    example: string
                    name: string
                withClick: false
                x: 0
                "y": 0
              timeout: 0
              type: string
        browserVariables:
            - example: string
              id: string
              name: string
              pattern: string
              secure: false
              type: string
        configVariables:
            - example: string
              id: string
              name: string
              pattern: string
              secure: false
              type: string
        deviceIds:
            - string
        locations:
            - string
        message: string
        name: string
        optionsList:
            acceptSelfSigned: false
            allowInsecure: false
            checkCertificateRevocation: false
            ci:
                executionRule: string
            disableCors: false
            disableCsp: false
            followRedirects: false
            httpVersion: string
            ignoreServerCertificateError: false
            initialNavigationTimeout: 0
            minFailureDuration: 0
            minLocationFailed: 0
            monitorName: string
            monitorOptions:
                renotifyInterval: 0
            monitorPriority: 0
            noScreenshot: false
            restrictedRoles:
                - string
            retry:
                count: 0
                interval: 0
            rumSettings:
                applicationId: string
                clientTokenId: 0
                isEnabled: false
            scheduling:
                timeframes:
                    - day: 0
                      from: string
                      to: string
                timezone: string
            tickEvery: 0
        requestBasicauth:
            accessKey: string
            accessTokenUrl: string
            audience: string
            clientId: string
            clientSecret: string
            domain: string
            password: string
            region: string
            resource: string
            scope: string
            secretKey: string
            serviceName: string
            sessionToken: string
            tokenApiAuthentication: string
            type: string
            username: string
            workstation: string
        requestClientCertificate:
            cert:
                content: string
                filename: string
            key:
                content: string
                filename: string
        requestDefinition:
            body: string
            bodyType: string
            callType: string
            certificateDomains:
                - string
            dnsServer: string
            dnsServerPort: 0
            host: string
            httpVersion: string
            message: string
            method: string
            noSavingResponseBody: false
            numberOfPackets: 0
            persistCookies: false
            plainProtoFile: string
            port: 0
            servername: string
            service: string
            shouldTrackHops: false
            timeout: 0
            url: string
        requestHeaders:
            string: any
        requestMetadata:
            string: any
        requestProxy:
            headers:
                string: any
            url: string
        requestQuery:
            string: any
        setCookie: string
        status: string
        subtype: string
        tags:
            - string
        type: string
    

    SyntheticsTest Resource Properties

    To learn more about resource properties and how to use them, see Inputs and Outputs in the Architecture and Concepts docs.

    Inputs

    The SyntheticsTest resource accepts the following input properties:

    Locations List<string>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    Name string
    Name of Datadog synthetics test.
    Status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    Type string
    Synthetics test type. Valid values are api, browser.
    ApiSteps List<SyntheticsTestApiStep>
    Steps for multistep api tests
    Assertions List<SyntheticsTestAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    BrowserSteps List<SyntheticsTestBrowserStep>
    Steps for browser tests.
    BrowserVariables List<SyntheticsTestBrowserVariable>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    ConfigVariables List<SyntheticsTestConfigVariable>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    DeviceIds List<string>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    Message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    OptionsList SyntheticsTestOptionsList
    RequestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    RequestHeaders Dictionary<string, object>
    Header name and value map.
    RequestMetadata Dictionary<string, object>
    Metadata to include when performing the gRPC test.
    RequestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    RequestQuery Dictionary<string, object>
    Query arguments name and value map.
    SetCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    Subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    Tags List<string>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    Locations []string
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    Name string
    Name of Datadog synthetics test.
    Status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    Type string
    Synthetics test type. Valid values are api, browser.
    ApiSteps []SyntheticsTestApiStepArgs
    Steps for multistep api tests
    Assertions []SyntheticsTestAssertionArgs
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    BrowserSteps []SyntheticsTestBrowserStepArgs
    Steps for browser tests.
    BrowserVariables []SyntheticsTestBrowserVariableArgs
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    ConfigVariables []SyntheticsTestConfigVariableArgs
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    DeviceIds []string
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    Message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    OptionsList SyntheticsTestOptionsListArgs
    RequestBasicauth SyntheticsTestRequestBasicauthArgs
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestRequestClientCertificateArgs
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestRequestDefinitionArgs
    Required if type = "api". The synthetics test request.
    RequestHeaders map[string]interface{}
    Header name and value map.
    RequestMetadata map[string]interface{}
    Metadata to include when performing the gRPC test.
    RequestProxy SyntheticsTestRequestProxyArgs
    The proxy to perform the test.
    RequestQuery map[string]interface{}
    Query arguments name and value map.
    SetCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    Subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    Tags []string
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    locations List<String>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    name String
    Name of Datadog synthetics test.
    status String
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    type String
    Synthetics test type. Valid values are api, browser.
    apiSteps List<SyntheticsTestApiStep>
    Steps for multistep api tests
    assertions List<SyntheticsTestAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps List<SyntheticsTestBrowserStep>
    Steps for browser tests.
    browserVariables List<SyntheticsTestBrowserVariable>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables List<SyntheticsTestConfigVariable>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds List<String>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    message String
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    optionsList SyntheticsTestOptionsList
    requestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    requestHeaders Map<String,Object>
    Header name and value map.
    requestMetadata Map<String,Object>
    Metadata to include when performing the gRPC test.
    requestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    requestQuery Map<String,Object>
    Query arguments name and value map.
    setCookie String
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    subtype String
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags List<String>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    locations string[]
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    name string
    Name of Datadog synthetics test.
    status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    type string
    Synthetics test type. Valid values are api, browser.
    apiSteps SyntheticsTestApiStep[]
    Steps for multistep api tests
    assertions SyntheticsTestAssertion[]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps SyntheticsTestBrowserStep[]
    Steps for browser tests.
    browserVariables SyntheticsTestBrowserVariable[]
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables SyntheticsTestConfigVariable[]
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds string[]
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    optionsList SyntheticsTestOptionsList
    requestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    requestHeaders {[key: string]: any}
    Header name and value map.
    requestMetadata {[key: string]: any}
    Metadata to include when performing the gRPC test.
    requestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    requestQuery {[key: string]: any}
    Query arguments name and value map.
    setCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags string[]
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    locations Sequence[str]
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    name str
    Name of Datadog synthetics test.
    status str
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    type str
    Synthetics test type. Valid values are api, browser.
    api_steps Sequence[SyntheticsTestApiStepArgs]
    Steps for multistep api tests
    assertions Sequence[SyntheticsTestAssertionArgs]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browser_steps Sequence[SyntheticsTestBrowserStepArgs]
    Steps for browser tests.
    browser_variables Sequence[SyntheticsTestBrowserVariableArgs]
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    config_variables Sequence[SyntheticsTestConfigVariableArgs]
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    device_ids Sequence[str]
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    message str
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    options_list SyntheticsTestOptionsListArgs
    request_basicauth SyntheticsTestRequestBasicauthArgs
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    request_client_certificate SyntheticsTestRequestClientCertificateArgs
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    request_definition SyntheticsTestRequestDefinitionArgs
    Required if type = "api". The synthetics test request.
    request_headers Mapping[str, Any]
    Header name and value map.
    request_metadata Mapping[str, Any]
    Metadata to include when performing the gRPC test.
    request_proxy SyntheticsTestRequestProxyArgs
    The proxy to perform the test.
    request_query Mapping[str, Any]
    Query arguments name and value map.
    set_cookie str
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    subtype str
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags Sequence[str]
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    locations List<String>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    name String
    Name of Datadog synthetics test.
    status String
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    type String
    Synthetics test type. Valid values are api, browser.
    apiSteps List<Property Map>
    Steps for multistep api tests
    assertions List<Property Map>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps List<Property Map>
    Steps for browser tests.
    browserVariables List<Property Map>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables List<Property Map>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds List<String>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    message String
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    optionsList Property Map
    requestBasicauth Property Map
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate Property Map
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition Property Map
    Required if type = "api". The synthetics test request.
    requestHeaders Map<Any>
    Header name and value map.
    requestMetadata Map<Any>
    Metadata to include when performing the gRPC test.
    requestProxy Property Map
    The proxy to perform the test.
    requestQuery Map<Any>
    Query arguments name and value map.
    setCookie String
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    subtype String
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags List<String>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).

    Outputs

    All input properties are implicitly available as output properties. Additionally, the SyntheticsTest resource produces the following output properties:

    Id string
    The provider-assigned unique ID for this managed resource.
    MonitorId int
    ID of the monitor associated with the Datadog synthetics test.
    Id string
    The provider-assigned unique ID for this managed resource.
    MonitorId int
    ID of the monitor associated with the Datadog synthetics test.
    id String
    The provider-assigned unique ID for this managed resource.
    monitorId Integer
    ID of the monitor associated with the Datadog synthetics test.
    id string
    The provider-assigned unique ID for this managed resource.
    monitorId number
    ID of the monitor associated with the Datadog synthetics test.
    id str
    The provider-assigned unique ID for this managed resource.
    monitor_id int
    ID of the monitor associated with the Datadog synthetics test.
    id String
    The provider-assigned unique ID for this managed resource.
    monitorId Number
    ID of the monitor associated with the Datadog synthetics test.

    Look up Existing SyntheticsTest Resource

    Get an existing SyntheticsTest resource’s state with the given name, ID, and optional extra properties used to qualify the lookup.

    public static get(name: string, id: Input<ID>, state?: SyntheticsTestState, opts?: CustomResourceOptions): SyntheticsTest
    @staticmethod
    def get(resource_name: str,
            id: str,
            opts: Optional[ResourceOptions] = None,
            api_steps: Optional[Sequence[SyntheticsTestApiStepArgs]] = None,
            assertions: Optional[Sequence[SyntheticsTestAssertionArgs]] = None,
            browser_steps: Optional[Sequence[SyntheticsTestBrowserStepArgs]] = None,
            browser_variables: Optional[Sequence[SyntheticsTestBrowserVariableArgs]] = None,
            config_variables: Optional[Sequence[SyntheticsTestConfigVariableArgs]] = None,
            device_ids: Optional[Sequence[str]] = None,
            locations: Optional[Sequence[str]] = None,
            message: Optional[str] = None,
            monitor_id: Optional[int] = None,
            name: Optional[str] = None,
            options_list: Optional[SyntheticsTestOptionsListArgs] = None,
            request_basicauth: Optional[SyntheticsTestRequestBasicauthArgs] = None,
            request_client_certificate: Optional[SyntheticsTestRequestClientCertificateArgs] = None,
            request_definition: Optional[SyntheticsTestRequestDefinitionArgs] = None,
            request_headers: Optional[Mapping[str, Any]] = None,
            request_metadata: Optional[Mapping[str, Any]] = None,
            request_proxy: Optional[SyntheticsTestRequestProxyArgs] = None,
            request_query: Optional[Mapping[str, Any]] = None,
            set_cookie: Optional[str] = None,
            status: Optional[str] = None,
            subtype: Optional[str] = None,
            tags: Optional[Sequence[str]] = None,
            type: Optional[str] = None) -> SyntheticsTest
    func GetSyntheticsTest(ctx *Context, name string, id IDInput, state *SyntheticsTestState, opts ...ResourceOption) (*SyntheticsTest, error)
    public static SyntheticsTest Get(string name, Input<string> id, SyntheticsTestState? state, CustomResourceOptions? opts = null)
    public static SyntheticsTest get(String name, Output<String> id, SyntheticsTestState state, CustomResourceOptions options)
    Resource lookup is not supported in YAML
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    resource_name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    name
    The unique name of the resulting resource.
    id
    The unique provider ID of the resource to lookup.
    state
    Any extra arguments used during the lookup.
    opts
    A bag of options that control this resource's behavior.
    The following state arguments are supported:
    ApiSteps List<SyntheticsTestApiStep>
    Steps for multistep api tests
    Assertions List<SyntheticsTestAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    BrowserSteps List<SyntheticsTestBrowserStep>
    Steps for browser tests.
    BrowserVariables List<SyntheticsTestBrowserVariable>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    ConfigVariables List<SyntheticsTestConfigVariable>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    DeviceIds List<string>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    Locations List<string>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    Message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    MonitorId int
    ID of the monitor associated with the Datadog synthetics test.
    Name string
    Name of Datadog synthetics test.
    OptionsList SyntheticsTestOptionsList
    RequestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    RequestHeaders Dictionary<string, object>
    Header name and value map.
    RequestMetadata Dictionary<string, object>
    Metadata to include when performing the gRPC test.
    RequestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    RequestQuery Dictionary<string, object>
    Query arguments name and value map.
    SetCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    Status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    Subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    Tags List<string>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    Type string
    Synthetics test type. Valid values are api, browser.
    ApiSteps []SyntheticsTestApiStepArgs
    Steps for multistep api tests
    Assertions []SyntheticsTestAssertionArgs
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    BrowserSteps []SyntheticsTestBrowserStepArgs
    Steps for browser tests.
    BrowserVariables []SyntheticsTestBrowserVariableArgs
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    ConfigVariables []SyntheticsTestConfigVariableArgs
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    DeviceIds []string
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    Locations []string
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    Message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    MonitorId int
    ID of the monitor associated with the Datadog synthetics test.
    Name string
    Name of Datadog synthetics test.
    OptionsList SyntheticsTestOptionsListArgs
    RequestBasicauth SyntheticsTestRequestBasicauthArgs
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestRequestClientCertificateArgs
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestRequestDefinitionArgs
    Required if type = "api". The synthetics test request.
    RequestHeaders map[string]interface{}
    Header name and value map.
    RequestMetadata map[string]interface{}
    Metadata to include when performing the gRPC test.
    RequestProxy SyntheticsTestRequestProxyArgs
    The proxy to perform the test.
    RequestQuery map[string]interface{}
    Query arguments name and value map.
    SetCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    Status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    Subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    Tags []string
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    Type string
    Synthetics test type. Valid values are api, browser.
    apiSteps List<SyntheticsTestApiStep>
    Steps for multistep api tests
    assertions List<SyntheticsTestAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps List<SyntheticsTestBrowserStep>
    Steps for browser tests.
    browserVariables List<SyntheticsTestBrowserVariable>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables List<SyntheticsTestConfigVariable>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds List<String>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    locations List<String>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    message String
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    monitorId Integer
    ID of the monitor associated with the Datadog synthetics test.
    name String
    Name of Datadog synthetics test.
    optionsList SyntheticsTestOptionsList
    requestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    requestHeaders Map<String,Object>
    Header name and value map.
    requestMetadata Map<String,Object>
    Metadata to include when performing the gRPC test.
    requestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    requestQuery Map<String,Object>
    Query arguments name and value map.
    setCookie String
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    status String
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    subtype String
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags List<String>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    type String
    Synthetics test type. Valid values are api, browser.
    apiSteps SyntheticsTestApiStep[]
    Steps for multistep api tests
    assertions SyntheticsTestAssertion[]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps SyntheticsTestBrowserStep[]
    Steps for browser tests.
    browserVariables SyntheticsTestBrowserVariable[]
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables SyntheticsTestConfigVariable[]
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds string[]
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    locations string[]
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    message string
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    monitorId number
    ID of the monitor associated with the Datadog synthetics test.
    name string
    Name of Datadog synthetics test.
    optionsList SyntheticsTestOptionsList
    requestBasicauth SyntheticsTestRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestRequestDefinition
    Required if type = "api". The synthetics test request.
    requestHeaders {[key: string]: any}
    Header name and value map.
    requestMetadata {[key: string]: any}
    Metadata to include when performing the gRPC test.
    requestProxy SyntheticsTestRequestProxy
    The proxy to perform the test.
    requestQuery {[key: string]: any}
    Query arguments name and value map.
    setCookie string
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    status string
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    subtype string
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags string[]
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    type string
    Synthetics test type. Valid values are api, browser.
    api_steps Sequence[SyntheticsTestApiStepArgs]
    Steps for multistep api tests
    assertions Sequence[SyntheticsTestAssertionArgs]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browser_steps Sequence[SyntheticsTestBrowserStepArgs]
    Steps for browser tests.
    browser_variables Sequence[SyntheticsTestBrowserVariableArgs]
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    config_variables Sequence[SyntheticsTestConfigVariableArgs]
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    device_ids Sequence[str]
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    locations Sequence[str]
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    message str
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    monitor_id int
    ID of the monitor associated with the Datadog synthetics test.
    name str
    Name of Datadog synthetics test.
    options_list SyntheticsTestOptionsListArgs
    request_basicauth SyntheticsTestRequestBasicauthArgs
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    request_client_certificate SyntheticsTestRequestClientCertificateArgs
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    request_definition SyntheticsTestRequestDefinitionArgs
    Required if type = "api". The synthetics test request.
    request_headers Mapping[str, Any]
    Header name and value map.
    request_metadata Mapping[str, Any]
    Metadata to include when performing the gRPC test.
    request_proxy SyntheticsTestRequestProxyArgs
    The proxy to perform the test.
    request_query Mapping[str, Any]
    Query arguments name and value map.
    set_cookie str
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    status str
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    subtype str
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags Sequence[str]
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    type str
    Synthetics test type. Valid values are api, browser.
    apiSteps List<Property Map>
    Steps for multistep api tests
    assertions List<Property Map>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    browserSteps List<Property Map>
    Steps for browser tests.
    browserVariables List<Property Map>
    Variables used for a browser test steps. Multiple variable blocks are allowed with the structure below.
    configVariables List<Property Map>
    Variables used for the test configuration. Multiple config_variable blocks are allowed with the structure below.
    deviceIds List<String>
    Required if type = "browser". Array with the different device IDs used to run the test. Valid values are laptop_large, tablet, mobile_small, chrome.laptop_large, chrome.tablet, chrome.mobile_small, firefox.laptop_large, firefox.tablet, firefox.mobile_small, edge.laptop_large, edge.tablet, edge.mobile_small.
    locations List<String>
    Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations.
    message String
    A message to include with notifications for this synthetics test. Email notifications can be sent to specific users by using the same @username notation as events. Defaults to "".
    monitorId Number
    ID of the monitor associated with the Datadog synthetics test.
    name String
    Name of Datadog synthetics test.
    optionsList Property Map
    requestBasicauth Property Map
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate Property Map
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition Property Map
    Required if type = "api". The synthetics test request.
    requestHeaders Map<Any>
    Header name and value map.
    requestMetadata Map<Any>
    Metadata to include when performing the gRPC test.
    requestProxy Property Map
    The proxy to perform the test.
    requestQuery Map<Any>
    Query arguments name and value map.
    setCookie String
    Cookies to be used for a browser test request, using the Set-Cookie syntax.
    status String
    Define whether you want to start (live) or pause (paused) a Synthetic test. Valid values are live, paused.
    subtype String
    The subtype of the Synthetic API test. Defaults to http. Valid values are http, ssl, tcp, dns, multi, icmp, udp, websocket, grpc.
    tags List<String>
    A list of tags to associate with your synthetics test. This can help you categorize and filter tests in the manage synthetics page of the UI. Default is an empty list ([]).
    type String
    Synthetics test type. Valid values are api, browser.

    Supporting Types

    SyntheticsTestApiStep, SyntheticsTestApiStepArgs

    Name string
    The name of the step.
    AllowFailure bool
    Determines whether or not to continue with test if this step fails.
    Assertions List<SyntheticsTestApiStepAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    ExtractedValues List<SyntheticsTestApiStepExtractedValue>
    Values to parse and save as variables from the response.
    IsCritical bool
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    RequestBasicauth SyntheticsTestApiStepRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestApiStepRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestApiStepRequestDefinition
    The request for the api step.
    RequestHeaders Dictionary<string, object>
    Header name and value map.
    RequestProxy SyntheticsTestApiStepRequestProxy
    The proxy to perform the test.
    RequestQuery Dictionary<string, object>
    Query arguments name and value map.
    Retry SyntheticsTestApiStepRetry
    Subtype string
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".
    Name string
    The name of the step.
    AllowFailure bool
    Determines whether or not to continue with test if this step fails.
    Assertions []SyntheticsTestApiStepAssertion
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    ExtractedValues []SyntheticsTestApiStepExtractedValue
    Values to parse and save as variables from the response.
    IsCritical bool
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    RequestBasicauth SyntheticsTestApiStepRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    RequestClientCertificate SyntheticsTestApiStepRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    RequestDefinition SyntheticsTestApiStepRequestDefinition
    The request for the api step.
    RequestHeaders map[string]interface{}
    Header name and value map.
    RequestProxy SyntheticsTestApiStepRequestProxy
    The proxy to perform the test.
    RequestQuery map[string]interface{}
    Query arguments name and value map.
    Retry SyntheticsTestApiStepRetry
    Subtype string
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".
    name String
    The name of the step.
    allowFailure Boolean
    Determines whether or not to continue with test if this step fails.
    assertions List<SyntheticsTestApiStepAssertion>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    extractedValues List<SyntheticsTestApiStepExtractedValue>
    Values to parse and save as variables from the response.
    isCritical Boolean
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    requestBasicauth SyntheticsTestApiStepRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestApiStepRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestApiStepRequestDefinition
    The request for the api step.
    requestHeaders Map<String,Object>
    Header name and value map.
    requestProxy SyntheticsTestApiStepRequestProxy
    The proxy to perform the test.
    requestQuery Map<String,Object>
    Query arguments name and value map.
    retry SyntheticsTestApiStepRetry
    subtype String
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".
    name string
    The name of the step.
    allowFailure boolean
    Determines whether or not to continue with test if this step fails.
    assertions SyntheticsTestApiStepAssertion[]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    extractedValues SyntheticsTestApiStepExtractedValue[]
    Values to parse and save as variables from the response.
    isCritical boolean
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    requestBasicauth SyntheticsTestApiStepRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate SyntheticsTestApiStepRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition SyntheticsTestApiStepRequestDefinition
    The request for the api step.
    requestHeaders {[key: string]: any}
    Header name and value map.
    requestProxy SyntheticsTestApiStepRequestProxy
    The proxy to perform the test.
    requestQuery {[key: string]: any}
    Query arguments name and value map.
    retry SyntheticsTestApiStepRetry
    subtype string
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".
    name str
    The name of the step.
    allow_failure bool
    Determines whether or not to continue with test if this step fails.
    assertions Sequence[SyntheticsTestApiStepAssertion]
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    extracted_values Sequence[SyntheticsTestApiStepExtractedValue]
    Values to parse and save as variables from the response.
    is_critical bool
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    request_basicauth SyntheticsTestApiStepRequestBasicauth
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    request_client_certificate SyntheticsTestApiStepRequestClientCertificate
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    request_definition SyntheticsTestApiStepRequestDefinition
    The request for the api step.
    request_headers Mapping[str, Any]
    Header name and value map.
    request_proxy SyntheticsTestApiStepRequestProxy
    The proxy to perform the test.
    request_query Mapping[str, Any]
    Query arguments name and value map.
    retry SyntheticsTestApiStepRetry
    subtype str
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".
    name String
    The name of the step.
    allowFailure Boolean
    Determines whether or not to continue with test if this step fails.
    assertions List<Property Map>
    Assertions used for the test. Multiple assertion blocks are allowed with the structure below.
    extractedValues List<Property Map>
    Values to parse and save as variables from the response.
    isCritical Boolean
    Determines whether or not to consider the entire test as failed if this step fails. Can be used only if allow_failure is true.
    requestBasicauth Property Map
    The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
    requestClientCertificate Property Map
    Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
    requestDefinition Property Map
    The request for the api step.
    requestHeaders Map<Any>
    Header name and value map.
    requestProxy Property Map
    The proxy to perform the test.
    requestQuery Map<Any>
    Query arguments name and value map.
    retry Property Map
    subtype String
    The subtype of the Synthetic multistep API test step. Valid values are http, grpc. Defaults to "http".

    SyntheticsTestApiStepAssertion, SyntheticsTestApiStepAssertionArgs

    Operator string
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    Type string
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    Property string
    If assertion type is header, this is the header name.
    Target string
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    Targetjsonpath SyntheticsTestApiStepAssertionTargetjsonpath
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    Targetxpath SyntheticsTestApiStepAssertionTargetxpath
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    TimingsScope string
    Timings scope for response time assertions. Valid values are all, withoutDNS.
    Operator string
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    Type string
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    Property string
    If assertion type is header, this is the header name.
    Target string
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    Targetjsonpath SyntheticsTestApiStepAssertionTargetjsonpath
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    Targetxpath SyntheticsTestApiStepAssertionTargetxpath
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    TimingsScope string
    Timings scope for response time assertions. Valid values are all, withoutDNS.
    operator String
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    type String
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    property String
    If assertion type is header, this is the header name.
    target String
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    targetjsonpath SyntheticsTestApiStepAssertionTargetjsonpath
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    targetxpath SyntheticsTestApiStepAssertionTargetxpath
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    timingsScope String
    Timings scope for response time assertions. Valid values are all, withoutDNS.
    operator string
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    type string
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    property string
    If assertion type is header, this is the header name.
    target string
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    targetjsonpath SyntheticsTestApiStepAssertionTargetjsonpath
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    targetxpath SyntheticsTestApiStepAssertionTargetxpath
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    timingsScope string
    Timings scope for response time assertions. Valid values are all, withoutDNS.
    operator str
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    type str
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    property str
    If assertion type is header, this is the header name.
    target str
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    targetjsonpath SyntheticsTestApiStepAssertionTargetjsonpath
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    targetxpath SyntheticsTestApiStepAssertionTargetxpath
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    timings_scope str
    Timings scope for response time assertions. Valid values are all, withoutDNS.
    operator String
    Assertion operator. Note Only some combinations of type and operator are valid (please refer to Datadog documentation).
    type String
    Type of assertion. Note Only some combinations of type and operator are valid (please refer to Datadog documentation). Valid values are body, header, statusCode, certificate, responseTime, property, recordEvery, recordSome, tlsVersion, minTlsVersion, latency, packetLossPercentage, packetsReceived, networkHop, receivedMessage, grpcHealthcheckStatus, grpcMetadata, grpcProto, connection.
    property String
    If assertion type is header, this is the header name.
    target String
    Expected value. Depends on the assertion type, refer to Datadog documentation for details.
    targetjsonpath Property Map
    Expected structure if operator is validatesJSONPath. Exactly one nested block is allowed with the structure below.
    targetxpath Property Map
    Expected structure if operator is validatesXPath. Exactly one nested block is allowed with the structure below.
    timingsScope String
    Timings scope for response time assertions. Valid values are all, withoutDNS.

    SyntheticsTestApiStepAssertionTargetjsonpath, SyntheticsTestApiStepAssertionTargetjsonpathArgs

    Jsonpath string
    The JSON path to assert.
    Operator string
    The specific operator to use on the path.
    Targetvalue string
    Expected matching value.
    Jsonpath string
    The JSON path to assert.
    Operator string
    The specific operator to use on the path.
    Targetvalue string
    Expected matching value.
    jsonpath String
    The JSON path to assert.
    operator String
    The specific operator to use on the path.
    targetvalue String
    Expected matching value.
    jsonpath string
    The JSON path to assert.
    operator string
    The specific operator to use on the path.
    targetvalue string
    Expected matching value.
    jsonpath str
    The JSON path to assert.
    operator str
    The specific operator to use on the path.
    targetvalue str
    Expected matching value.
    jsonpath String
    The JSON path to assert.
    operator String
    The specific operator to use on the path.
    targetvalue String
    Expected matching value.

    SyntheticsTestApiStepAssertionTargetxpath, SyntheticsTestApiStepAssertionTargetxpathArgs

    Operator string
    The specific operator to use on the path.
    Xpath string
    The xpath to assert.
    Targetvalue string
    Expected matching value.
    Operator string
    The specific operator to use on the path.
    Xpath string
    The xpath to assert.
    Targetvalue string
    Expected matching value.
    operator String
    The specific operator to use on the path.
    xpath String
    The xpath to assert.
    targetvalue String
    Expected matching value.
    operator string
    The specific operator to use on the path.
    xpath string
    The xpath to assert.
    targetvalue string
    Expected matching value.
    operator str
    The specific operator to use on the path.
    xpath str
    The xpath to assert.
    targetvalue str
    Expected matching value.
    operator String
    The specific operator to use on the path.
    xpath String
    The xpath to assert.
    targetvalue String
    Expected matching value.

    SyntheticsTestApiStepExtractedValue, SyntheticsTestApiStepExtractedValueArgs

    Name string
    Parser SyntheticsTestApiStepExtractedValueParser
    Type string
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    Field string
    When type is http_header, name of the header to use to extract the value.
    Secure bool
    Determines whether or not the extracted value will be obfuscated.
    Name string
    Parser SyntheticsTestApiStepExtractedValueParser
    Type string
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    Field string
    When type is http_header, name of the header to use to extract the value.
    Secure bool
    Determines whether or not the extracted value will be obfuscated.
    name String
    parser SyntheticsTestApiStepExtractedValueParser
    type String
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    field String
    When type is http_header, name of the header to use to extract the value.
    secure Boolean
    Determines whether or not the extracted value will be obfuscated.
    name string
    parser SyntheticsTestApiStepExtractedValueParser
    type string
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    field string
    When type is http_header, name of the header to use to extract the value.
    secure boolean
    Determines whether or not the extracted value will be obfuscated.
    name str
    parser SyntheticsTestApiStepExtractedValueParser
    type str
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    field str
    When type is http_header, name of the header to use to extract the value.
    secure bool
    Determines whether or not the extracted value will be obfuscated.
    name String
    parser Property Map
    type String
    Property of the Synthetics Test Response to use for the variable. Valid values are http_body, http_header, local_variable.
    field String
    When type is http_header, name of the header to use to extract the value.
    secure Boolean
    Determines whether or not the extracted value will be obfuscated.

    SyntheticsTestApiStepExtractedValueParser, SyntheticsTestApiStepExtractedValueParserArgs

    Type string
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    Value string
    Regex or JSON path used for the parser. Not used with type raw.
    Type string
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    Value string
    Regex or JSON path used for the parser. Not used with type raw.
    type String
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    value String
    Regex or JSON path used for the parser. Not used with type raw.
    type string
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    value string
    Regex or JSON path used for the parser. Not used with type raw.
    type str
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    value str
    Regex or JSON path used for the parser. Not used with type raw.
    type String
    Type of parser for a Synthetics global variable from a synthetics test. Valid values are raw, json_path, regex, x_path.
    value String
    Regex or JSON path used for the parser. Not used with type raw.

    SyntheticsTestApiStepRequestBasicauth, SyntheticsTestApiStepRequestBasicauthArgs

    AccessKey string
    Access key for SIGV4 authentication.
    AccessTokenUrl string
    Access token url for oauth-client or oauth-rop authentication.
    Audience string
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    ClientId string
    Client ID for oauth-client or oauth-rop authentication.
    ClientSecret string
    Client secret for oauth-client or oauth-rop authentication.
    Domain string
    Domain for ntlm authentication.
    Password string
    Password for authentication.
    Region string
    Region for SIGV4 authentication.
    Resource string
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    Scope string
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    SecretKey string
    Secret key for SIGV4 authentication.
    ServiceName string
    Service name for SIGV4 authentication.
    SessionToken string
    Session token for SIGV4 authentication.
    TokenApiAuthentication string
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    Type string
    Type of basic authentication to use when performing the test. Defaults to "web".
    Username string
    Username for authentication.
    Workstation string
    Workstation for ntlm authentication.
    AccessKey string
    Access key for SIGV4 authentication.
    AccessTokenUrl string
    Access token url for oauth-client or oauth-rop authentication.
    Audience string
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    ClientId string
    Client ID for oauth-client or oauth-rop authentication.
    ClientSecret string
    Client secret for oauth-client or oauth-rop authentication.
    Domain string
    Domain for ntlm authentication.
    Password string
    Password for authentication.
    Region string
    Region for SIGV4 authentication.
    Resource string
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    Scope string
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    SecretKey string
    Secret key for SIGV4 authentication.
    ServiceName string
    Service name for SIGV4 authentication.
    SessionToken string
    Session token for SIGV4 authentication.
    TokenApiAuthentication string
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    Type string
    Type of basic authentication to use when performing the test. Defaults to "web".
    Username string
    Username for authentication.
    Workstation string
    Workstation for ntlm authentication.
    accessKey String
    Access key for SIGV4 authentication.
    accessTokenUrl String
    Access token url for oauth-client or oauth-rop authentication.
    audience String
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    clientId String
    Client ID for oauth-client or oauth-rop authentication.
    clientSecret String
    Client secret for oauth-client or oauth-rop authentication.
    domain String
    Domain for ntlm authentication.
    password String
    Password for authentication.
    region String
    Region for SIGV4 authentication.
    resource String
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    scope String
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    secretKey String
    Secret key for SIGV4 authentication.
    serviceName String
    Service name for SIGV4 authentication.
    sessionToken String
    Session token for SIGV4 authentication.
    tokenApiAuthentication String
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    type String
    Type of basic authentication to use when performing the test. Defaults to "web".
    username String
    Username for authentication.
    workstation String
    Workstation for ntlm authentication.
    accessKey string
    Access key for SIGV4 authentication.
    accessTokenUrl string
    Access token url for oauth-client or oauth-rop authentication.
    audience string
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    clientId string
    Client ID for oauth-client or oauth-rop authentication.
    clientSecret string
    Client secret for oauth-client or oauth-rop authentication.
    domain string
    Domain for ntlm authentication.
    password string
    Password for authentication.
    region string
    Region for SIGV4 authentication.
    resource string
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    scope string
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    secretKey string
    Secret key for SIGV4 authentication.
    serviceName string
    Service name for SIGV4 authentication.
    sessionToken string
    Session token for SIGV4 authentication.
    tokenApiAuthentication string
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    type string
    Type of basic authentication to use when performing the test. Defaults to "web".
    username string
    Username for authentication.
    workstation string
    Workstation for ntlm authentication.
    access_key str
    Access key for SIGV4 authentication.
    access_token_url str
    Access token url for oauth-client or oauth-rop authentication.
    audience str
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    client_id str
    Client ID for oauth-client or oauth-rop authentication.
    client_secret str
    Client secret for oauth-client or oauth-rop authentication.
    domain str
    Domain for ntlm authentication.
    password str
    Password for authentication.
    region str
    Region for SIGV4 authentication.
    resource str
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    scope str
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    secret_key str
    Secret key for SIGV4 authentication.
    service_name str
    Service name for SIGV4 authentication.
    session_token str
    Session token for SIGV4 authentication.
    token_api_authentication str
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    type str
    Type of basic authentication to use when performing the test. Defaults to "web".
    username str
    Username for authentication.
    workstation str
    Workstation for ntlm authentication.
    accessKey String
    Access key for SIGV4 authentication.
    accessTokenUrl String
    Access token url for oauth-client or oauth-rop authentication.
    audience String
    Audience for oauth-client or oauth-rop authentication. Defaults to "".
    clientId String
    Client ID for oauth-client or oauth-rop authentication.
    clientSecret String
    Client secret for oauth-client or oauth-rop authentication.
    domain String
    Domain for ntlm authentication.
    password String
    Password for authentication.
    region String
    Region for SIGV4 authentication.
    resource String
    Resource for oauth-client or oauth-rop authentication. Defaults to "".
    scope String
    Scope for oauth-client or oauth-rop authentication. Defaults to "".
    secretKey String
    Secret key for SIGV4 authentication.
    serviceName String
    Service name for SIGV4 authentication.
    sessionToken String
    Session token for SIGV4 authentication.
    tokenApiAuthentication String
    Token API Authentication for oauth-client or oauth-rop authentication. Valid values are header, body.
    type String
    Type of basic authentication to use when performing the test. Defaults to "web".
    username String
    Username for authentication.
    workstation String
    Workstation for ntlm authentication.

    SyntheticsTestApiStepRequestClientCertificate, SyntheticsTestApiStepRequestClientCertificateArgs

    SyntheticsTestApiStepRequestClientCertificateCert, SyntheticsTestApiStepRequestClientCertificateCertArgs

    Content string
    Content of the certificate.
    Filename string
    File name for the certificate.
    Content string
    Content of the certificate.
    Filename string
    File name for the certificate.
    content String
    Content of the certificate.
    filename String
    File name for the certificate.
    content string
    Content of the certificate.
    filename string
    File name for the certificate.
    content str
    Content of the certificate.
    filename str
    File name for the certificate.
    content String
    Content of the certificate.
    filename String
    File name for the certificate.

    SyntheticsTestApiStepRequestClientCertificateKey, SyntheticsTestApiStepRequestClientCertificateKeyArgs

    Content string
    Content of the certificate.
    Filename string
    File name for the certificate.
    Content string
    Content of the certificate.
    Filename string
    File name for the certificate.
    content String
    Content of the certificate.
    filename String
    File name for the certificate.
    content string
    Content of the certificate.
    filename string
    File name for the certificate.
    content str
    Content of the certificate.
    filename str
    File name for the certificate.
    content String
    Content of the certificate.
    filename String
    File name for the certificate.

    SyntheticsTestApiStepRequestDefinition, SyntheticsTestApiStepRequestDefinitionArgs

    AllowInsecure bool
    Allows loading insecure content for an HTTP request in an API test or in a multistep API test step.
    Body string
    The request body.
    BodyType string
    Type of the request body. Valid values are text/plain, application/json, text/xml, text/html, application/x-www-form-urlencoded, graphql, application/octet-stream, multipart/form-data.
    CallType string
    The type of gRPC call to perform. Valid values are healthcheck, unary.
    CertificateDomains List<string>
    By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in certificate_domains.
    DnsServer string
    DNS server to use for DNS tests (subtype = "dns").
    DnsServerPort int
    DNS server port to use for DNS tests.
    FollowRedirects bool
    Determines whether or not the API HTTP test should follow redirects.
    Host string
    Host name to perform the test with.
    HttpVersion string
    HTTP version to use for an HTTP request in an API test or step. Valid values are http1, http2, any.
    Message string
    For UDP and websocket tests, message to send with the request.
    Method string
    Either the HTTP method/verb to use or a gRPC method available on the service set in the service field. Required if subtype is HTTP or if subtype is grpc and callType is unary.
    NoSavingResponseBody bool
    Determines whether or not to save the response body.
    NumberOfPackets int
    Number of pings to use per test for ICMP tests (subtype = "icmp") between 0 and 10.
    PersistCookies bool
    Persist cookies across redirects.
    PlainProtoFile string
    The content of a proto file as a string.
    Port int
    Port to use when performing the test.
    ProtoJsonDescriptor string
    A protobuf JSON descriptor. Deprecated. Use plain_proto_file instead.

    Deprecated: Use plain_proto_file instead.

    Servername string
    For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.
    Service string
    The gRPC service on which you want to perform the gRPC call.
    ShouldTrackHops bool
    This will turn on a traceroute probe to discover all gateways along the path to the host destination. For ICMP tests (subtype = "icmp").
    Timeout int
    Timeout in seconds for the test. Defaults to 60.
    Url string
    The URL to send the request to.
    AllowInsecure bool
    Allows loading insecure content for an HTTP request in an API test or in a multistep API test step.
    Body string
    The request body.
    BodyType string
    Type of the request body. Valid values are text/plain, application/json, text/xml, text/html, application/x-www-form-urlencoded, graphql, application/octet-stream, multipart/form-data.
    CallType string
    The type of gRPC call to perform. Valid values are healthcheck, unary.
    CertificateDomains []string
    By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in certificate_domains.
    DnsServer string
    DNS server to use for DNS tests (subtype = "dns").
    DnsServerPort int
    DNS server port to use for DNS tests.
    FollowRedirects bool
    Determines whether or not the API HTTP test should follow redirects.
    Host string
    Host name to perform the test with.
    HttpVersion string
    HTTP version to use for an HTTP request in an API test or step. Valid values are http1, http2, any.
    Message string
    For UDP and websocket tests, message to send with the request.
    Method string
    Either the HTTP method/verb to use or a gRPC method available on the service set in the service field. Required if subtype is HTTP or if subtype is grpc and callType is unary.
    NoSavingResponseBody bool
    Determines whether or not to save the response body.
    NumberOfPackets int
    Number of pings to use per test for ICMP tests (subtype = "icmp") between 0 and 10.
    PersistCookies bool
    Persist cookies across redirects.
    PlainProtoFile string
    The content of a proto file as a string.
    Port int
    Port to use when performing the test.
    ProtoJsonDescriptor string
    A protobuf JSON descriptor. Deprecated. Use plain_proto_file instead.

    Deprecated: Use plain_proto_file instead.

    Servername string
    For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.
    Service string
    The gRPC service on which you want to perform the gRPC call.
    ShouldTrackHops bool
    This will turn on a traceroute probe to discover all gateways along the path to the host destination. For ICMP tests (subtype = "icmp").
    Timeout int
    Timeout in seconds for the test. Defaults to 60.
    Url string
    The URL to send the request to.
    allowInsecure Boolean
    Allows loading insecure content for an HTTP request in an API test or in a multistep API test step.
    body String
    The request body.
    bodyType String
    Type of the request body. Valid values are text/plain, application/json, text/xml, text/html, application/x-www-form-urlencoded, graphql, application/octet-stream, multipart/form-data.
    callType String
    The type of gRPC call to perform. Valid values are healthcheck, unary.
    certificateDomains List<String>
    By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in certificate_domains.
    dnsServer String
    DNS server to use for DNS tests (subtype = "dns").
    dnsServerPort Integer
    DNS server port to use for DNS tests.
    followRedirects Boolean
    Determines whether or not the API HTTP test should follow redirects.
    host String
    Host name to perform the test with.
    httpVersion String
    HTTP version to use for an HTTP request in an API test or step. Valid values are http1, http2, any.
    message String
    For UDP and websocket tests, message to send with the request.
    method String
    Either the HTTP method/verb to use or a gRPC method available on the service set in the service field. Required if subtype is HTTP or if subtype is grpc and callType is unary.
    noSavingResponseBody Boolean
    Determines whether or not to save the response body.
    numberOfPackets Integer
    Number of pings to use per test for ICMP tests (subtype = "icmp") between 0 and 10.
    persistCookies Boolean
    Persist cookies across redirects.
    plainProtoFile String
    The content of a proto file as a string.
    port Integer
    Port to use when performing the test.
    protoJsonDescriptor String
    A protobuf JSON descriptor. Deprecated. Use plain_proto_file instead.

    Deprecated: Use plain_proto_file instead.

    servername String
    For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.
    service String
    The gRPC service on which you want to perform the gRPC call.
    shouldTrackHops Boolean
    This will turn on a traceroute probe to discover all gateways along the path to the host destination. For ICMP tests (subtype = "icmp").
    timeout Integer
    Timeout in seconds for the test. Defaults to 60.
    url String
    The URL to send the request to.
    allowInsecure boolean
    Allows loading insecure content for an HTTP request in an API test or in a multistep API test step.
    body string
    The request body.
    bodyType string
    Type of the request body. Valid values are text/plain, application/json, text/xml, text/html, application/x-www-form-urlencoded, graphql, application/octet-stream, multipart/form-data.
    callType string
    The type of gRPC call to perform. Valid values are healthcheck, unary.
    certificateDomains string[]
    By default, the client certificate is applied on the domain of the starting URL for browser tests. If you want your client certificate to be applied on other domains instead, add them in certificate_domains.
    dnsServer string
    DNS server to use for DNS tests (subtype = "dns").
    dnsServerPort number
    DNS server port to use for DNS tests.
    followRedirects boolean
    Determines whether or not the API HTTP test should follow redirects.
    host string
    Host name to perform the test with.
    httpVersion string
    HTTP version to use for an HTTP request in an API test or step. Valid values are http1, http2, any.
    message string
    For UDP and websocket tests, message to send with the request.
    method string
    Either the HTTP method/verb to use or a gRPC method available on the service set in the service field. Required if subtype is HTTP or if subtype is grpc and callType is unary.
    noSavingResponseBody boolean
    Determines whether or not to save the response body.
    numberOfPackets number
    Number of pings to use per test for ICMP tests (subtype = "icmp") between 0 and 10.
    persistCookies boolean
    Persist cookies across redirects.
    plainProtoFile string
    The content of a proto file as a string.
    port number
    Port to use when performing the test.
    protoJsonDescriptor string
    A protobuf JSON descriptor. Deprecated. Use plain_proto_file instead.

    Deprecated: Use plain_proto_file instead.

    servername string
    For SSL tests, it specifies on which server you want to initiate the TLS handshake, allowing the server to present one of multiple possible certificates on the same IP address and TCP port number.
    service string
    The gRPC service on which you want to perform the gRPC call.
    shouldTrackHops boolean
    This will turn on a traceroute probe to discover all gateways along the path to the host destination. For ICMP tests (subtype = "icmp").
    timeout number
    Timeout in seconds for the test. Defaults to 60.