import * as pulumi from "@pulumi/pulumi";
import * as inputs from "./types/input";
import * as outputs from "./types/output";
/**
 * 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 `configVariable` 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):
 *
 * to
 *
 * which you can now use in your request definition:
 *
 * ## Example Usage
 *
 * ```typescript
 * 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,
 *             escalationMessage: "test escalation message",
 *         },
 *     },
 * });
 * // 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 ICMP test)
 * // Create a new Datadog Synthetics ICMP test on example.org
 * const testApiIcmp = new datadog.SyntheticsTest("test_api_icmp", {
 *     name: "ICMP Test on example.com",
 *     type: "api",
 *     subtype: "icmp",
 *     status: "live",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.com",
 *         noSavingResponseBody: false,
 *         numberOfPackets: 1,
 *         persistCookies: false,
 *         shouldTrackHops: false,
 *         timeout: 0,
 *     },
 *     assertions: [
 *         {
 *             operator: "is",
 *             target: "0",
 *             type: "packetLossPercentage",
 *         },
 *         {
 *             operator: "lessThan",
 *             property: "avg",
 *             target: "1000",
 *             type: "latency",
 *         },
 *         {
 *             operator: "moreThanOrEqual",
 *             target: "1",
 *             type: "packetsReceived",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *         retry: {
 *             count: 2,
 *             interval: 300,
 *         },
 *         monitorOptions: {
 *             renotifyInterval: 120,
 *         },
 *     },
 * });
 * // 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://www.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",
 *             },
 *         },
 *         {
 *             name: "A gRPC health check on example.org",
 *             subtype: "grpc",
 *             assertions: [{
 *                 type: "grpcMetadata",
 *                 operator: "is",
 *                 property: "X-Header",
 *                 target: "test",
 *             }],
 *             requestDefinition: {
 *                 host: "example.org",
 *                 port: "443",
 *                 callType: "healthcheck",
 *                 service: "greeter.Greeter",
 *             },
 *         },
 *         {
 *             name: "A gRPC behavior check on example.org",
 *             subtype: "grpc",
 *             assertions: [{
 *                 type: "grpcHealthcheckStatus",
 *                 operator: "is",
 *                 target: "1",
 *             }],
 *             requestDefinition: {
 *                 host: "example.org",
 *                 port: "443",
 *                 callType: "unary",
 *                 service: "greeter.Greeter",
 *                 method: "SayHello",
 *                 message: "{\"name\": \"John\"}",
 *                 plainProtoFile: `syntax = "proto3";
 *
 * package greeter;
 *
 * // 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;
 * }
 * `,
 *             },
 *         },
 *     ],
 *     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://www.example.org",
 *     },
 *     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",
 *                     },
 *                 }),
 *             },
 *         },
 *         {
 *             name: "Upload a file",
 *             type: "uploadFiles",
 *             params: {
 *                 files: JSON.stringify([{
 *                     name: "hello.txt",
 *                     size: 11,
 *                     content: "Hello world",
 *                 }]),
 *                 elementUserLocator: {
 *                     value: {
 *                         type: "css",
 *                         value: "#simple-file-upload",
 *                     },
 *                 },
 *                 element: JSON.stringify({
 *                     userLocator: {
 *                         failTestOnCannotLocate: true,
 *                         values: [{
 *                             type: "css",
 *                             value: "#simple-file-upload",
 *                         }],
 *                     },
 *                 }),
 *             },
 *         },
 *         {
 *             name: "Test sending http requests",
 *             type: "assertRequests",
 *             params: {
 *                 requests: JSON.stringify({
 *                     count: {
 *                         type: "equals",
 *                         value: 1,
 *                     },
 *                     url: "https://www.example.org",
 *                 }),
 *             },
 *         },
 *         {
 *             name: "Run api test",
 *             type: "runApiTest",
 *             params: {
 *                 request: JSON.stringify({
 *                     config: {
 *                         assertions: [{
 *                             type: "statusCode",
 *                             operator: "is",
 *                             target: 200,
 *                         }],
 *                         request: {
 *                             method: "GET",
 *                             url: "https://example.com",
 *                         },
 *                     },
 *                     options: {},
 *                     subtype: "http",
 *                 }),
 *             },
 *         },
 *     ],
 *     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 (Synthetics Mobile test)
 * // Create a new Datadog Synthetics Mobile test starting on https://www.example.org
 * const testMobile = new datadog.SyntheticsTest("test_mobile", {
 *     type: "mobile",
 *     name: "A Mobile test on example.org",
 *     status: "paused",
 *     message: "Notify @datadog.user",
 *     tags: [
 *         "foo:bar",
 *         "baz",
 *     ],
 *     configVariables: [{
 *         example: "123",
 *         name: "VARIABLE_NAME",
 *         pattern: "{{numeric(3)}}",
 *         type: "text",
 *         secure: false,
 *     }],
 *     configInitialApplicationArguments: {
 *         test_process_argument: "test1",
 *     },
 *     deviceIds: ["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
 *     locations: ["aws:eu-central-1"],
 *     mobileOptionsList: {
 *         minFailureDuration: 0,
 *         retry: {
 *             count: 0,
 *             interval: 300,
 *         },
 *         tickEvery: 43200,
 *         scheduling: {
 *             timeframes: [
 *                 {
 *                     day: 5,
 *                     from: "07:00",
 *                     to: "16:00",
 *                 },
 *                 {
 *                     day: 7,
 *                     from: "07:00",
 *                     to: "16:00",
 *                 },
 *             ],
 *             timezone: "UTC",
 *         },
 *         monitorName: "mobile-test-monitor",
 *         monitorOptions: {
 *             renotifyInterval: 10,
 *             escalationMessage: "test escalation message",
 *             renotifyOccurrences: 3,
 *             notificationPresetName: "show_all",
 *         },
 *         monitorPriority: 5,
 *         ci: {
 *             executionRule: "blocking",
 *         },
 *         defaultStepTimeout: 10,
 *         deviceIds: ["synthetics:mobile:device:apple_iphone_14_plus_ios_16"],
 *         noScreenshot: true,
 *         allowApplicationCrash: false,
 *         disableAutoAcceptAlert: true,
 *         mobileApplication: {
 *             applicationId: "5f055d15-0000-aaaa-zzzz-6739f83346aa",
 *             referenceId: "434d4719-0000-aaaa-zzzz-31082b544718",
 *             referenceType: "version",
 *         },
 *     },
 *     mobileSteps: [
 *         {
 *             name: "Tap on StaticText \"Tap\"",
 *             params: {
 *                 element: {
 *                     context: "NATIVE_APP",
 *                     viewName: "StaticText",
 *                     contextType: "native",
 *                     textContent: "Tap",
 *                     multiLocator: {},
 *                     relativePosition: {
 *                         x: 0.07256155303030302,
 *                         y: 0.41522381756756754,
 *                     },
 *                     userLocator: {
 *                         failTestOnCannotLocate: false,
 *                         values: [{
 *                             type: "id",
 *                             value: "some_id",
 *                         }],
 *                     },
 *                     elementDescription: "<XCUIElementTypeStaticText value=\"Tap\" name=\"Tap\" label=\"Tap\">",
 *                 },
 *             },
 *             timeout: 100,
 *             type: "tap",
 *             allowFailure: false,
 *             isCritical: true,
 *             noScreenshot: false,
 *             hasNewStepElement: false,
 *         },
 *         {
 *             name: "Test View \"Tap\" content",
 *             params: {
 *                 check: "contains",
 *                 value: "Tap",
 *                 element: {
 *                     context: "NATIVE_APP",
 *                     viewName: "View",
 *                     contextType: "native",
 *                     textContent: "Tap",
 *                     multiLocator: {},
 *                     relativePosition: {
 *                         x: 0.27660448306074764,
 *                         y: 0.6841517857142857,
 *                     },
 *                     userLocator: {
 *                         failTestOnCannotLocate: false,
 *                         values: [{
 *                             type: "id",
 *                             value: "some_id",
 *                         }],
 *                     },
 *                     elementDescription: "<XCUIElementTypeOther name=\"Tap\" label=\"Tap\">",
 *                 },
 *             },
 *             timeout: 100,
 *             type: "assertElementContent",
 *             allowFailure: false,
 *             isCritical: true,
 *             noScreenshot: false,
 *             hasNewStepElement: false,
 *         },
 *     ],
 * });
 * // Example Usage (GRPC API behavior check test)
 * // Create a new Datadog GRPC API test calling host example.org on port 443
 * // targeting service `greeter.Greeter` with the method `SayHello`
 * // and the message {"name": "John"}
 * const testGrpcUnary = new datadog.SyntheticsTest("test_grpc_unary", {
 *     name: "GRPC API behavior check test",
 *     type: "api",
 *     subtype: "grpc",
 *     status: "live",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.org",
 *         port: "443",
 *         callType: "unary",
 *         service: "greeter.Greeter",
 *         method: "SayHello",
 *         message: "{\"name\": \"John\"}",
 *         plainProtoFile: `syntax = "proto3";
 *
 * package greeter;
 *
 * // 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",
 *             type: "grpcProto",
 *             target: "proto target",
 *         },
 *         {
 *             operator: "is",
 *             property: "property",
 *             type: "grpcMetadata",
 *             target: "123",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *     },
 * });
 * // Example Usage (GRPC API health check test)
 * // Create a new Datadog GRPC API test calling host example.org on port 443
 * // testing the overall health of the service
 * const testGrpcHealth = new datadog.SyntheticsTest("test_grpc_health", {
 *     name: "GRPC API health check test",
 *     type: "api",
 *     subtype: "grpc",
 *     status: "live",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.org",
 *         port: "443",
 *         callType: "healthcheck",
 *         service: "greeter.Greeter",
 *     },
 *     assertions: [
 *         {
 *             type: "responseTime",
 *             operator: "lessThan",
 *             target: "2000",
 *         },
 *         {
 *             operator: "is",
 *             type: "grpcHealthcheckStatus",
 *             target: "1",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *     },
 * });
 * // Example Usage (TCP Network Path Test)
 * // Create a new Datadog TCP Network Path test to example.com on port 443
 * // using the TCP traceroute strategy "syn"
 * const networkTcp = new datadog.SyntheticsTest("network_tcp", {
 *     name: "TCP Network Path Test",
 *     type: "network",
 *     subtype: "tcp",
 *     status: "live",
 *     message: "Notify @pagerduty",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.com",
 *         port: "443",
 *         e2eQueries: 5,
 *         maxTtl: 30,
 *         tracerouteQueries: 3,
 *         tcpMethod: "syn",
 *         timeout: 10,
 *     },
 *     assertions: [
 *         {
 *             type: "latency",
 *             operator: "lessThan",
 *             property: "avg",
 *             target: "200",
 *         },
 *         {
 *             type: "latency",
 *             operator: "lessThan",
 *             property: "max",
 *             target: "500",
 *         },
 *         {
 *             type: "jitter",
 *             operator: "lessThan",
 *             target: "50",
 *         },
 *         {
 *             type: "packetLossPercentage",
 *             operator: "lessThan",
 *             target: "0.5",
 *         },
 *         {
 *             type: "multiNetworkHop",
 *             operator: "lessThan",
 *             property: "max",
 *             target: "20",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *         retry: {
 *             count: 2,
 *             interval: 300,
 *         },
 *         monitorOptions: {
 *             renotifyInterval: 120,
 *         },
 *     },
 * });
 * // Example Usage (UDP Network Path Test)
 * // Create a new Datadog UDP Network Path test to example.com on port 53
 * const networkUdp = new datadog.SyntheticsTest("network_udp", {
 *     name: "UDP Network Path Test",
 *     type: "network",
 *     subtype: "udp",
 *     status: "live",
 *     message: "Notify @pagerduty",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.com",
 *         port: "53",
 *         e2eQueries: 5,
 *         maxTtl: 30,
 *         tracerouteQueries: 3,
 *         timeout: 10,
 *     },
 *     assertions: [
 *         {
 *             type: "latency",
 *             operator: "lessThan",
 *             property: "avg",
 *             target: "100.2",
 *         },
 *         {
 *             type: "jitter",
 *             operator: "lessThan",
 *             target: "20",
 *         },
 *         {
 *             type: "packetLossPercentage",
 *             operator: "lessThan",
 *             target: "0.1",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *         retry: {
 *             count: 2,
 *             interval: 300,
 *         },
 *         monitorOptions: {
 *             renotifyInterval: 120,
 *         },
 *     },
 * });
 * // Example Usage (ICMP Network Path Test)
 * // Create a new Datadog ICMP Network Path test to example.com
 * const networkIcmp = new datadog.SyntheticsTest("network_icmp", {
 *     name: "ICMP Network Path Test",
 *     type: "network",
 *     subtype: "icmp",
 *     status: "live",
 *     message: "Notify @pagerduty",
 *     locations: ["aws:eu-central-1"],
 *     tags: [
 *         "foo:bar",
 *         "foo",
 *         "env:test",
 *     ],
 *     requestDefinition: {
 *         host: "example.com",
 *         e2eQueries: 5,
 *         maxTtl: 30,
 *         tracerouteQueries: 3,
 *         timeout: 10,
 *     },
 *     assertions: [
 *         {
 *             type: "latency",
 *             operator: "lessThan",
 *             property: "avg",
 *             target: "150",
 *         },
 *         {
 *             type: "latency",
 *             operator: "lessThan",
 *             property: "max",
 *             target: "300",
 *         },
 *         {
 *             type: "jitter",
 *             operator: "lessThan",
 *             target: "30",
 *         },
 *         {
 *             type: "packetLossPercentage",
 *             operator: "lessThan",
 *             target: "0.5",
 *         },
 *         {
 *             type: "multiNetworkHop",
 *             operator: "lessThan",
 *             property: "avg",
 *             target: "15",
 *         },
 *     ],
 *     optionsList: {
 *         tickEvery: 900,
 *         retry: {
 *             count: 2,
 *             interval: 300,
 *         },
 *         monitorOptions: {
 *             renotifyInterval: 120,
 *         },
 *     },
 * });
 * ```
 *
 * ## Import
 *
 * Synthetics tests can be imported using their public string ID, e.g.
 *
 * ```sh
 * $ pulumi import datadog:index/syntheticsTest:SyntheticsTest fizz abc-123-xyz
 * ```
 */
export declare class SyntheticsTest extends pulumi.CustomResource {
    /**
     * Get an existing SyntheticsTest resource's state with the given name, ID, and optional extra
     * properties used to qualify the lookup.
     *
     * @param name The _unique_ name of the resulting resource.
     * @param id The _unique_ provider ID of the resource to lookup.
     * @param state Any extra arguments used during the lookup.
     * @param opts Optional settings to control the behavior of the CustomResource.
     */
    static get(name: string, id: pulumi.Input<pulumi.ID>, state?: SyntheticsTestState, opts?: pulumi.CustomResourceOptions): SyntheticsTest;
    /**
     * Returns true if the given object is an instance of SyntheticsTest.  This is designed to work even
     * when multiple copies of the Pulumi SDK have been loaded into the same process.
     */
    static isInstance(obj: any): obj is SyntheticsTest;
    /**
     * Steps for multistep API tests
     */
    readonly apiSteps: pulumi.Output<outputs.SyntheticsTestApiStep[] | undefined>;
    /**
     * Assertions used for the test. Multiple `assertion` blocks are allowed with the structure below.
     */
    readonly assertions: pulumi.Output<outputs.SyntheticsTestAssertion[] | undefined>;
    /**
     * Steps for browser tests.
     */
    readonly browserSteps: pulumi.Output<outputs.SyntheticsTestBrowserStep[] | undefined>;
    /**
     * Variables used for a browser test steps. Multiple `variable` blocks are allowed with the structure below.
     */
    readonly browserVariables: pulumi.Output<outputs.SyntheticsTestBrowserVariable[] | undefined>;
    /**
     * Initial application arguments for the mobile test.
     */
    readonly configInitialApplicationArguments: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Variables used for the test configuration. Multiple `configVariable` blocks are allowed with the structure below.
     */
    readonly configVariables: pulumi.Output<outputs.SyntheticsTestConfigVariable[] | undefined>;
    /**
     * Required if `type = "browser"`. Array with the different device IDs used to run the test.
     */
    readonly deviceIds: pulumi.Output<string[] | undefined>;
    /**
     * A boolean indicating whether this synthetics test can be deleted even if it's referenced by other resources (for example, SLOs and composite monitors).
     */
    readonly forceDeleteDependencies: pulumi.Output<boolean | undefined>;
    /**
     * Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations or find the possible values listed in [this API response](https://app.datadoghq.com/api/v1/synthetics/locations?only_public=true).
     */
    readonly locations: pulumi.Output<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 `""`.
     */
    readonly message: pulumi.Output<string | undefined>;
    readonly mobileOptionsList: pulumi.Output<outputs.SyntheticsTestMobileOptionsList | undefined>;
    /**
     * Steps for mobile tests
     */
    readonly mobileSteps: pulumi.Output<outputs.SyntheticsTestMobileStep[] | undefined>;
    /**
     * ID of the monitor associated with the Datadog synthetics test.
     */
    readonly monitorId: pulumi.Output<number>;
    /**
     * Name of Datadog synthetics test.
     */
    readonly name: pulumi.Output<string>;
    readonly optionsList: pulumi.Output<outputs.SyntheticsTestOptionsList | undefined>;
    /**
     * The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
     */
    readonly requestBasicauth: pulumi.Output<outputs.SyntheticsTestRequestBasicauth | undefined>;
    /**
     * Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
     */
    readonly requestClientCertificate: pulumi.Output<outputs.SyntheticsTestRequestClientCertificate | undefined>;
    /**
     * Required if `type = "api"`. The synthetics test request.
     */
    readonly requestDefinition: pulumi.Output<outputs.SyntheticsTestRequestDefinition | undefined>;
    /**
     * Files to be used as part of the request in the test.
     */
    readonly requestFiles: pulumi.Output<outputs.SyntheticsTestRequestFile[] | undefined>;
    /**
     * Header name and value map.
     */
    readonly requestHeaders: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Metadata to include when performing the gRPC request.
     */
    readonly requestMetadata: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * The proxy to perform the test.
     */
    readonly requestProxy: pulumi.Output<outputs.SyntheticsTestRequestProxy | undefined>;
    /**
     * Query arguments name and value map.
     */
    readonly requestQuery: pulumi.Output<{
        [key: string]: string;
    } | undefined>;
    /**
     * Cookies to be used for a browser test request, using the [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie) syntax.
     */
    readonly setCookie: pulumi.Output<string | undefined>;
    /**
     * Define whether you want to start (`live`) or pause (`paused`) a Synthetic test. Valid values are `live`, `paused`.
     */
    readonly status: pulumi.Output<string>;
    /**
     * The subtype for API or Network Path tests. For API tests, defaults to `http`. For Network Path tests, only `tcp`, `udp`, `icmp` are available. Valid values are `http`, `ssl`, `tcp`, `dns`, `multi`, `icmp`, `udp`, `websocket`, `grpc`.
     */
    readonly subtype: pulumi.Output<string | undefined>;
    /**
     * 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 (`[]`).
     */
    readonly tags: pulumi.Output<string[] | undefined>;
    /**
     * The type of Synthetics test. Valid values are `api`, `browser`, `mobile`, `network`.
     */
    readonly type: pulumi.Output<string>;
    /**
     * Variables defined from JavaScript code for API HTTP tests.
     */
    readonly variablesFromScript: pulumi.Output<string | undefined>;
    /**
     * Create a SyntheticsTest resource with the given unique name, arguments, and options.
     *
     * @param name The _unique_ name of the resource.
     * @param args The arguments to use to populate this resource's properties.
     * @param opts A bag of options that control this resource's behavior.
     */
    constructor(name: string, args: SyntheticsTestArgs, opts?: pulumi.CustomResourceOptions);
}
/**
 * Input properties used for looking up and filtering SyntheticsTest resources.
 */
export interface SyntheticsTestState {
    /**
     * Steps for multistep API tests
     */
    apiSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestApiStep>[]>;
    /**
     * Assertions used for the test. Multiple `assertion` blocks are allowed with the structure below.
     */
    assertions?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestAssertion>[]>;
    /**
     * Steps for browser tests.
     */
    browserSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestBrowserStep>[]>;
    /**
     * Variables used for a browser test steps. Multiple `variable` blocks are allowed with the structure below.
     */
    browserVariables?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestBrowserVariable>[]>;
    /**
     * Initial application arguments for the mobile test.
     */
    configInitialApplicationArguments?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Variables used for the test configuration. Multiple `configVariable` blocks are allowed with the structure below.
     */
    configVariables?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestConfigVariable>[]>;
    /**
     * Required if `type = "browser"`. Array with the different device IDs used to run the test.
     */
    deviceIds?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * A boolean indicating whether this synthetics test can be deleted even if it's referenced by other resources (for example, SLOs and composite monitors).
     */
    forceDeleteDependencies?: pulumi.Input<boolean>;
    /**
     * Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations or find the possible values listed in [this API response](https://app.datadoghq.com/api/v1/synthetics/locations?only_public=true).
     */
    locations?: pulumi.Input<pulumi.Input<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 `""`.
     */
    message?: pulumi.Input<string>;
    mobileOptionsList?: pulumi.Input<inputs.SyntheticsTestMobileOptionsList>;
    /**
     * Steps for mobile tests
     */
    mobileSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestMobileStep>[]>;
    /**
     * ID of the monitor associated with the Datadog synthetics test.
     */
    monitorId?: pulumi.Input<number>;
    /**
     * Name of Datadog synthetics test.
     */
    name?: pulumi.Input<string>;
    optionsList?: pulumi.Input<inputs.SyntheticsTestOptionsList>;
    /**
     * The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
     */
    requestBasicauth?: pulumi.Input<inputs.SyntheticsTestRequestBasicauth>;
    /**
     * Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
     */
    requestClientCertificate?: pulumi.Input<inputs.SyntheticsTestRequestClientCertificate>;
    /**
     * Required if `type = "api"`. The synthetics test request.
     */
    requestDefinition?: pulumi.Input<inputs.SyntheticsTestRequestDefinition>;
    /**
     * Files to be used as part of the request in the test.
     */
    requestFiles?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestRequestFile>[]>;
    /**
     * Header name and value map.
     */
    requestHeaders?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Metadata to include when performing the gRPC request.
     */
    requestMetadata?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The proxy to perform the test.
     */
    requestProxy?: pulumi.Input<inputs.SyntheticsTestRequestProxy>;
    /**
     * Query arguments name and value map.
     */
    requestQuery?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Cookies to be used for a browser test request, using the [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie) syntax.
     */
    setCookie?: pulumi.Input<string>;
    /**
     * Define whether you want to start (`live`) or pause (`paused`) a Synthetic test. Valid values are `live`, `paused`.
     */
    status?: pulumi.Input<string>;
    /**
     * The subtype for API or Network Path tests. For API tests, defaults to `http`. For Network Path tests, only `tcp`, `udp`, `icmp` are available. Valid values are `http`, `ssl`, `tcp`, `dns`, `multi`, `icmp`, `udp`, `websocket`, `grpc`.
     */
    subtype?: pulumi.Input<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 (`[]`).
     */
    tags?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The type of Synthetics test. Valid values are `api`, `browser`, `mobile`, `network`.
     */
    type?: pulumi.Input<string>;
    /**
     * Variables defined from JavaScript code for API HTTP tests.
     */
    variablesFromScript?: pulumi.Input<string>;
}
/**
 * The set of arguments for constructing a SyntheticsTest resource.
 */
export interface SyntheticsTestArgs {
    /**
     * Steps for multistep API tests
     */
    apiSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestApiStep>[]>;
    /**
     * Assertions used for the test. Multiple `assertion` blocks are allowed with the structure below.
     */
    assertions?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestAssertion>[]>;
    /**
     * Steps for browser tests.
     */
    browserSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestBrowserStep>[]>;
    /**
     * Variables used for a browser test steps. Multiple `variable` blocks are allowed with the structure below.
     */
    browserVariables?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestBrowserVariable>[]>;
    /**
     * Initial application arguments for the mobile test.
     */
    configInitialApplicationArguments?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Variables used for the test configuration. Multiple `configVariable` blocks are allowed with the structure below.
     */
    configVariables?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestConfigVariable>[]>;
    /**
     * Required if `type = "browser"`. Array with the different device IDs used to run the test.
     */
    deviceIds?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * A boolean indicating whether this synthetics test can be deleted even if it's referenced by other resources (for example, SLOs and composite monitors).
     */
    forceDeleteDependencies?: pulumi.Input<boolean>;
    /**
     * Array of locations used to run the test. Refer to the Datadog Synthetics location data source to retrieve the list of locations or find the possible values listed in [this API response](https://app.datadoghq.com/api/v1/synthetics/locations?only_public=true).
     */
    locations: pulumi.Input<pulumi.Input<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 `""`.
     */
    message?: pulumi.Input<string>;
    mobileOptionsList?: pulumi.Input<inputs.SyntheticsTestMobileOptionsList>;
    /**
     * Steps for mobile tests
     */
    mobileSteps?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestMobileStep>[]>;
    /**
     * Name of Datadog synthetics test.
     */
    name: pulumi.Input<string>;
    optionsList?: pulumi.Input<inputs.SyntheticsTestOptionsList>;
    /**
     * The HTTP basic authentication credentials. Exactly one nested block is allowed with the structure below.
     */
    requestBasicauth?: pulumi.Input<inputs.SyntheticsTestRequestBasicauth>;
    /**
     * Client certificate to use when performing the test request. Exactly one nested block is allowed with the structure below.
     */
    requestClientCertificate?: pulumi.Input<inputs.SyntheticsTestRequestClientCertificate>;
    /**
     * Required if `type = "api"`. The synthetics test request.
     */
    requestDefinition?: pulumi.Input<inputs.SyntheticsTestRequestDefinition>;
    /**
     * Files to be used as part of the request in the test.
     */
    requestFiles?: pulumi.Input<pulumi.Input<inputs.SyntheticsTestRequestFile>[]>;
    /**
     * Header name and value map.
     */
    requestHeaders?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Metadata to include when performing the gRPC request.
     */
    requestMetadata?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * The proxy to perform the test.
     */
    requestProxy?: pulumi.Input<inputs.SyntheticsTestRequestProxy>;
    /**
     * Query arguments name and value map.
     */
    requestQuery?: pulumi.Input<{
        [key: string]: pulumi.Input<string>;
    }>;
    /**
     * Cookies to be used for a browser test request, using the [Set-Cookie](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie) syntax.
     */
    setCookie?: pulumi.Input<string>;
    /**
     * Define whether you want to start (`live`) or pause (`paused`) a Synthetic test. Valid values are `live`, `paused`.
     */
    status: pulumi.Input<string>;
    /**
     * The subtype for API or Network Path tests. For API tests, defaults to `http`. For Network Path tests, only `tcp`, `udp`, `icmp` are available. Valid values are `http`, `ssl`, `tcp`, `dns`, `multi`, `icmp`, `udp`, `websocket`, `grpc`.
     */
    subtype?: pulumi.Input<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 (`[]`).
     */
    tags?: pulumi.Input<pulumi.Input<string>[]>;
    /**
     * The type of Synthetics test. Valid values are `api`, `browser`, `mobile`, `network`.
     */
    type: pulumi.Input<string>;
    /**
     * Variables defined from JavaScript code for API HTTP tests.
     */
    variablesFromScript?: pulumi.Input<string>;
}