checkly.AlertChannel

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

// An Email alert channel
const emailAc = new checkly.AlertChannel("email_ac", {
    email: {
        address: "john@example.com",
    },
    sendRecovery: true,
    sendFailure: false,
    sendDegraded: true,
    sslExpiry: true,
    sslExpiryThreshold: 22,
});
// A SMS alert channel
const smsAc = new checkly.AlertChannel("sms_ac", {
    sms: {
        name: "john",
        number: "+5491100001111",
    },
    sendRecovery: true,
    sendFailure: true,
});
// A Slack alert channel
const slackAc = new checkly.AlertChannel("slack_ac", {slack: {
    channel: "#checkly-notifications",
    url: "https://hooks.slack.com/services/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",
}});
// An Opsgenie alert channel
const opsgenieAc = new checkly.AlertChannel("opsgenie_ac", {opsgenie: {
    name: "opsalerts",
    apiKey: "fookey",
    region: "fooregion",
    priority: "foopriority",
}});
// A Pagerduty alert channel
const pagerdutyAc = new checkly.AlertChannel("pagerduty_ac", {pagerduty: {
    account: "checkly",
    serviceKey: "key1",
    serviceName: "pdalert",
}});
// A Webhook alert channel
const webhookAc = new checkly.AlertChannel("webhook_ac", {webhook: {
    name: "foo",
    method: "get",
    template: "footemplate",
    url: "https://example.com/foo",
    webhookSecret: "foosecret",
}});
// A Firehydran alert channel integration
const firehydrantAc = new checkly.AlertChannel("firehydrant_ac", {webhook: {
    name: "firehydrant",
    method: "post",
    template: `{
  "event": "{{ALERT_TITLE}}",
  "link": "{{RESULT_LINK}}",
  "check_id": "{{CHECK_ID}}",
  "check_type": "{{CHECK_TYPE}}",
  "alert_type": "{{ALERT_TYPE}}",
  "started_at": "{{STARTED_AT}}",
  "check_result_id": "{{CHECK_RESULT_ID}}"
},
`,
    url: "https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly",
    webhookType: "WEBHOOK_FIREHYDRANT",
}});
// Connecting the alert channel to a check
const exampleCheck = new checkly.Check("example_check", {
    name: "Example check",
    alertChannelSubscriptions: [
        {
            channelId: emailAc.id,
            activated: true,
        },
        {
            channelId: smsAc.id,
            activated: true,
        },
    ],
});

import pulumi
import pulumi_checkly as checkly

# An Email alert channel
email_ac = checkly.AlertChannel("email_ac",
    email={
        "address": "john@example.com",
    },
    send_recovery=True,
    send_failure=False,
    send_degraded=True,
    ssl_expiry=True,
    ssl_expiry_threshold=22)
# A SMS alert channel
sms_ac = checkly.AlertChannel("sms_ac",
    sms={
        "name": "john",
        "number": "+5491100001111",
    },
    send_recovery=True,
    send_failure=True)
# A Slack alert channel
slack_ac = checkly.AlertChannel("slack_ac", slack={
    "channel": "#checkly-notifications",
    "url": "https://hooks.slack.com/services/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",
})
# An Opsgenie alert channel
opsgenie_ac = checkly.AlertChannel("opsgenie_ac", opsgenie={
    "name": "opsalerts",
    "api_key": "fookey",
    "region": "fooregion",
    "priority": "foopriority",
})
# A Pagerduty alert channel
pagerduty_ac = checkly.AlertChannel("pagerduty_ac", pagerduty={
    "account": "checkly",
    "service_key": "key1",
    "service_name": "pdalert",
})
# A Webhook alert channel
webhook_ac = checkly.AlertChannel("webhook_ac", webhook={
    "name": "foo",
    "method": "get",
    "template": "footemplate",
    "url": "https://example.com/foo",
    "webhook_secret": "foosecret",
})
# A Firehydran alert channel integration
firehydrant_ac = checkly.AlertChannel("firehydrant_ac", webhook={
    "name": "firehydrant",
    "method": "post",
    "template": """{
  "event": "{{ALERT_TITLE}}",
  "link": "{{RESULT_LINK}}",
  "check_id": "{{CHECK_ID}}",
  "check_type": "{{CHECK_TYPE}}",
  "alert_type": "{{ALERT_TYPE}}",
  "started_at": "{{STARTED_AT}}",
  "check_result_id": "{{CHECK_RESULT_ID}}"
},
""",
    "url": "https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly",
    "webhook_type": "WEBHOOK_FIREHYDRANT",
})
# Connecting the alert channel to a check
example_check = checkly.Check("example_check",
    name="Example check",
    alert_channel_subscriptions=[
        {
            "channel_id": email_ac.id,
            "activated": True,
        },
        {
            "channel_id": sms_ac.id,
            "activated": True,
        },
    ])

package main

import (
	"github.com/checkly/pulumi-checkly/sdk/v2/go/checkly"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		// An Email alert channel
		emailAc, err := checkly.NewAlertChannel(ctx, "email_ac", &checkly.AlertChannelArgs{
			Email: &checkly.AlertChannelEmailArgs{
				Address: pulumi.String("john@example.com"),
			},
			SendRecovery:       pulumi.Bool(true),
			SendFailure:        pulumi.Bool(false),
			SendDegraded:       pulumi.Bool(true),
			SslExpiry:          pulumi.Bool(true),
			SslExpiryThreshold: pulumi.Int(22),
		})
		if err != nil {
			return err
		}
		// A SMS alert channel
		smsAc, err := checkly.NewAlertChannel(ctx, "sms_ac", &checkly.AlertChannelArgs{
			Sms: &checkly.AlertChannelSmsArgs{
				Name:   pulumi.String("john"),
				Number: pulumi.String("+5491100001111"),
			},
			SendRecovery: pulumi.Bool(true),
			SendFailure:  pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		// A Slack alert channel
		_, err = checkly.NewAlertChannel(ctx, "slack_ac", &checkly.AlertChannelArgs{
			Slack: &checkly.AlertChannelSlackArgs{
				Channel: pulumi.String("#checkly-notifications"),
				Url:     pulumi.String("https://hooks.slack.com/services/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"),
			},
		})
		if err != nil {
			return err
		}
		// An Opsgenie alert channel
		_, err = checkly.NewAlertChannel(ctx, "opsgenie_ac", &checkly.AlertChannelArgs{
			Opsgenie: &checkly.AlertChannelOpsgenieArgs{
				Name:     pulumi.String("opsalerts"),
				ApiKey:   pulumi.String("fookey"),
				Region:   pulumi.String("fooregion"),
				Priority: pulumi.String("foopriority"),
			},
		})
		if err != nil {
			return err
		}
		// A Pagerduty alert channel
		_, err = checkly.NewAlertChannel(ctx, "pagerduty_ac", &checkly.AlertChannelArgs{
			Pagerduty: &checkly.AlertChannelPagerdutyArgs{
				Account:     pulumi.String("checkly"),
				ServiceKey:  pulumi.String("key1"),
				ServiceName: pulumi.String("pdalert"),
			},
		})
		if err != nil {
			return err
		}
		// A Webhook alert channel
		_, err = checkly.NewAlertChannel(ctx, "webhook_ac", &checkly.AlertChannelArgs{
			Webhook: &checkly.AlertChannelWebhookArgs{
				Name:          pulumi.String("foo"),
				Method:        pulumi.String("get"),
				Template:      pulumi.String("footemplate"),
				Url:           pulumi.String("https://example.com/foo"),
				WebhookSecret: pulumi.String("foosecret"),
			},
		})
		if err != nil {
			return err
		}
		// A Firehydran alert channel integration
		_, err = checkly.NewAlertChannel(ctx, "firehydrant_ac", &checkly.AlertChannelArgs{
			Webhook: &checkly.AlertChannelWebhookArgs{
				Name:   pulumi.String("firehydrant"),
				Method: pulumi.String("post"),
				Template: pulumi.String(`{
  "event": "{{ALERT_TITLE}}",
  "link": "{{RESULT_LINK}}",
  "check_id": "{{CHECK_ID}}",
  "check_type": "{{CHECK_TYPE}}",
  "alert_type": "{{ALERT_TYPE}}",
  "started_at": "{{STARTED_AT}}",
  "check_result_id": "{{CHECK_RESULT_ID}}"
},
`),
				Url:         pulumi.String("https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly"),
				WebhookType: pulumi.String("WEBHOOK_FIREHYDRANT"),
			},
		})
		if err != nil {
			return err
		}
		// Connecting the alert channel to a check
		_, err = checkly.NewCheck(ctx, "example_check", &checkly.CheckArgs{
			Name: pulumi.String("Example check"),
			AlertChannelSubscriptions: checkly.CheckAlertChannelSubscriptionArray{
				&checkly.CheckAlertChannelSubscriptionArgs{
					ChannelId: emailAc.ID(),
					Activated: pulumi.Bool(true),
				},
				&checkly.CheckAlertChannelSubscriptionArgs{
					ChannelId: smsAc.ID(),
					Activated: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    // An Email alert channel
    var emailAc = new Checkly.AlertChannel("email_ac", new()
    {
        Email = new Checkly.Inputs.AlertChannelEmailArgs
        {
            Address = "john@example.com",
        },
        SendRecovery = true,
        SendFailure = false,
        SendDegraded = true,
        SslExpiry = true,
        SslExpiryThreshold = 22,
    });

    // A SMS alert channel
    var smsAc = new Checkly.AlertChannel("sms_ac", new()
    {
        Sms = new Checkly.Inputs.AlertChannelSmsArgs
        {
            Name = "john",
            Number = "+5491100001111",
        },
        SendRecovery = true,
        SendFailure = true,
    });

    // A Slack alert channel
    var slackAc = new Checkly.AlertChannel("slack_ac", new()
    {
        Slack = new Checkly.Inputs.AlertChannelSlackArgs
        {
            Channel = "#checkly-notifications",
            Url = "https://hooks.slack.com/services/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",
        },
    });

    // An Opsgenie alert channel
    var opsgenieAc = new Checkly.AlertChannel("opsgenie_ac", new()
    {
        Opsgenie = new Checkly.Inputs.AlertChannelOpsgenieArgs
        {
            Name = "opsalerts",
            ApiKey = "fookey",
            Region = "fooregion",
            Priority = "foopriority",
        },
    });

    // A Pagerduty alert channel
    var pagerdutyAc = new Checkly.AlertChannel("pagerduty_ac", new()
    {
        Pagerduty = new Checkly.Inputs.AlertChannelPagerdutyArgs
        {
            Account = "checkly",
            ServiceKey = "key1",
            ServiceName = "pdalert",
        },
    });

    // A Webhook alert channel
    var webhookAc = new Checkly.AlertChannel("webhook_ac", new()
    {
        Webhook = new Checkly.Inputs.AlertChannelWebhookArgs
        {
            Name = "foo",
            Method = "get",
            Template = "footemplate",
            Url = "https://example.com/foo",
            WebhookSecret = "foosecret",
        },
    });

    // A Firehydran alert channel integration
    var firehydrantAc = new Checkly.AlertChannel("firehydrant_ac", new()
    {
        Webhook = new Checkly.Inputs.AlertChannelWebhookArgs
        {
            Name = "firehydrant",
            Method = "post",
            Template = @"{
  ""event"": ""{{ALERT_TITLE}}"",
  ""link"": ""{{RESULT_LINK}}"",
  ""check_id"": ""{{CHECK_ID}}"",
  ""check_type"": ""{{CHECK_TYPE}}"",
  ""alert_type"": ""{{ALERT_TYPE}}"",
  ""started_at"": ""{{STARTED_AT}}"",
  ""check_result_id"": ""{{CHECK_RESULT_ID}}""
},
",
            Url = "https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly",
            WebhookType = "WEBHOOK_FIREHYDRANT",
        },
    });

    // Connecting the alert channel to a check
    var exampleCheck = new Checkly.Check("example_check", new()
    {
        Name = "Example check",
        AlertChannelSubscriptions = new[]
        {
            new Checkly.Inputs.CheckAlertChannelSubscriptionArgs
            {
                ChannelId = emailAc.Id,
                Activated = true,
            },
            new Checkly.Inputs.CheckAlertChannelSubscriptionArgs
            {
                ChannelId = smsAc.Id,
                Activated = true,
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.checkly.AlertChannel;
import com.pulumi.checkly.AlertChannelArgs;
import com.pulumi.checkly.inputs.AlertChannelEmailArgs;
import com.pulumi.checkly.inputs.AlertChannelSmsArgs;
import com.pulumi.checkly.inputs.AlertChannelSlackArgs;
import com.pulumi.checkly.inputs.AlertChannelOpsgenieArgs;
import com.pulumi.checkly.inputs.AlertChannelPagerdutyArgs;
import com.pulumi.checkly.inputs.AlertChannelWebhookArgs;
import com.pulumi.checkly.Check;
import com.pulumi.checkly.CheckArgs;
import com.pulumi.checkly.inputs.CheckAlertChannelSubscriptionArgs;
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) {
        // An Email alert channel
        var emailAc = new AlertChannel("emailAc", AlertChannelArgs.builder()
            .email(AlertChannelEmailArgs.builder()
                .address("john@example.com")
                .build())
            .sendRecovery(true)
            .sendFailure(false)
            .sendDegraded(true)
            .sslExpiry(true)
            .sslExpiryThreshold(22)
            .build());

        // A SMS alert channel
        var smsAc = new AlertChannel("smsAc", AlertChannelArgs.builder()
            .sms(AlertChannelSmsArgs.builder()
                .name("john")
                .number("+5491100001111")
                .build())
            .sendRecovery(true)
            .sendFailure(true)
            .build());

        // A Slack alert channel
        var slackAc = new AlertChannel("slackAc", AlertChannelArgs.builder()
            .slack(AlertChannelSlackArgs.builder()
                .channel("#checkly-notifications")
                .url("https://hooks.slack.com/services/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")
                .build())
            .build());

        // An Opsgenie alert channel
        var opsgenieAc = new AlertChannel("opsgenieAc", AlertChannelArgs.builder()
            .opsgenie(AlertChannelOpsgenieArgs.builder()
                .name("opsalerts")
                .apiKey("fookey")
                .region("fooregion")
                .priority("foopriority")
                .build())
            .build());

        // A Pagerduty alert channel
        var pagerdutyAc = new AlertChannel("pagerdutyAc", AlertChannelArgs.builder()
            .pagerduty(AlertChannelPagerdutyArgs.builder()
                .account("checkly")
                .serviceKey("key1")
                .serviceName("pdalert")
                .build())
            .build());

        // A Webhook alert channel
        var webhookAc = new AlertChannel("webhookAc", AlertChannelArgs.builder()
            .webhook(AlertChannelWebhookArgs.builder()
                .name("foo")
                .method("get")
                .template("footemplate")
                .url("https://example.com/foo")
                .webhookSecret("foosecret")
                .build())
            .build());

        // A Firehydran alert channel integration
        var firehydrantAc = new AlertChannel("firehydrantAc", AlertChannelArgs.builder()
            .webhook(AlertChannelWebhookArgs.builder()
                .name("firehydrant")
                .method("post")
                .template("""
{
  "event": "{{ALERT_TITLE}}",
  "link": "{{RESULT_LINK}}",
  "check_id": "{{CHECK_ID}}",
  "check_type": "{{CHECK_TYPE}}",
  "alert_type": "{{ALERT_TYPE}}",
  "started_at": "{{STARTED_AT}}",
  "check_result_id": "{{CHECK_RESULT_ID}}"
},
                """)
                .url("https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly")
                .webhookType("WEBHOOK_FIREHYDRANT")
                .build())
            .build());

        // Connecting the alert channel to a check
        var exampleCheck = new Check("exampleCheck", CheckArgs.builder()
            .name("Example check")
            .alertChannelSubscriptions(            
                CheckAlertChannelSubscriptionArgs.builder()
                    .channelId(emailAc.id())
                    .activated(true)
                    .build(),
                CheckAlertChannelSubscriptionArgs.builder()
                    .channelId(smsAc.id())
                    .activated(true)
                    .build())
            .build());

    }
}

resources:
  # An Email alert channel
  emailAc:
    type: checkly:AlertChannel
    name: email_ac
    properties:
      email:
        address: john@example.com
      sendRecovery: true
      sendFailure: false
      sendDegraded: true
      sslExpiry: true
      sslExpiryThreshold: 22
  # A SMS alert channel
  smsAc:
    type: checkly:AlertChannel
    name: sms_ac
    properties:
      sms:
        name: john
        number: '+5491100001111'
      sendRecovery: true
      sendFailure: true
  # A Slack alert channel
  slackAc:
    type: checkly:AlertChannel
    name: slack_ac
    properties:
      slack:
        channel: '#checkly-notifications'
        url: https://hooks.slack.com/services/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
  # An Opsgenie alert channel
  opsgenieAc:
    type: checkly:AlertChannel
    name: opsgenie_ac
    properties:
      opsgenie:
        name: opsalerts
        apiKey: fookey
        region: fooregion
        priority: foopriority
  # A Pagerduty alert channel
  pagerdutyAc:
    type: checkly:AlertChannel
    name: pagerduty_ac
    properties:
      pagerduty:
        account: checkly
        serviceKey: key1
        serviceName: pdalert
  # A Webhook alert channel
  webhookAc:
    type: checkly:AlertChannel
    name: webhook_ac
    properties:
      webhook:
        name: foo
        method: get
        template: footemplate
        url: https://example.com/foo
        webhookSecret: foosecret
  # A Firehydran alert channel integration
  firehydrantAc:
    type: checkly:AlertChannel
    name: firehydrant_ac
    properties:
      webhook:
        name: firehydrant
        method: post
        template: |
          {
            "event": "{{ALERT_TITLE}}",
            "link": "{{RESULT_LINK}}",
            "check_id": "{{CHECK_ID}}",
            "check_type": "{{CHECK_TYPE}}",
            "alert_type": "{{ALERT_TYPE}}",
            "started_at": "{{STARTED_AT}}",
            "check_result_id": "{{CHECK_RESULT_ID}}"
          },          
        url: https://app.firehydrant.io/integrations/alerting/webhooks/2/checkly
        webhookType: WEBHOOK_FIREHYDRANT
  # Connecting the alert channel to a check
  exampleCheck:
    type: checkly:Check
    name: example_check
    properties:
      name: Example check
      alertChannelSubscriptions:
        - channelId: ${emailAc.id}
          activated: true
        - channelId: ${smsAc.id}
          activated: true

var alertChannelResource = new Checkly.AlertChannel("alertChannelResource", new()
{
    Call = new Checkly.Inputs.AlertChannelCallArgs
    {
        Name = "string",
        Number = "string",
    },
    Email = new Checkly.Inputs.AlertChannelEmailArgs
    {
        Address = "string",
    },
    Opsgenie = new Checkly.Inputs.AlertChannelOpsgenieArgs
    {
        ApiKey = "string",
        Name = "string",
        Priority = "string",
        Region = "string",
    },
    Pagerduty = new Checkly.Inputs.AlertChannelPagerdutyArgs
    {
        ServiceKey = "string",
        Account = "string",
        ServiceName = "string",
    },
    SendDegraded = false,
    SendFailure = false,
    SendRecovery = false,
    Slack = new Checkly.Inputs.AlertChannelSlackArgs
    {
        Channel = "string",
        Url = "string",
    },
    Sms = new Checkly.Inputs.AlertChannelSmsArgs
    {
        Name = "string",
        Number = "string",
    },
    SslExpiry = false,
    SslExpiryThreshold = 0,
    Webhook = new Checkly.Inputs.AlertChannelWebhookArgs
    {
        Name = "string",
        Url = "string",
        Headers = 
        {
            { "string", "string" },
        },
        Method = "string",
        QueryParameters = 
        {
            { "string", "string" },
        },
        Template = "string",
        WebhookSecret = "string",
        WebhookType = "string",
    },
});

example, err := checkly.NewAlertChannel(ctx, "alertChannelResource", &checkly.AlertChannelArgs{
	Call: &checkly.AlertChannelCallArgs{
		Name:   pulumi.String("string"),
		Number: pulumi.String("string"),
	},
	Email: &checkly.AlertChannelEmailArgs{
		Address: pulumi.String("string"),
	},
	Opsgenie: &checkly.AlertChannelOpsgenieArgs{
		ApiKey:   pulumi.String("string"),
		Name:     pulumi.String("string"),
		Priority: pulumi.String("string"),
		Region:   pulumi.String("string"),
	},
	Pagerduty: &checkly.AlertChannelPagerdutyArgs{
		ServiceKey:  pulumi.String("string"),
		Account:     pulumi.String("string"),
		ServiceName: pulumi.String("string"),
	},
	SendDegraded: pulumi.Bool(false),
	SendFailure:  pulumi.Bool(false),
	SendRecovery: pulumi.Bool(false),
	Slack: &checkly.AlertChannelSlackArgs{
		Channel: pulumi.String("string"),
		Url:     pulumi.String("string"),
	},
	Sms: &checkly.AlertChannelSmsArgs{
		Name:   pulumi.String("string"),
		Number: pulumi.String("string"),
	},
	SslExpiry:          pulumi.Bool(false),
	SslExpiryThreshold: pulumi.Int(0),
	Webhook: &checkly.AlertChannelWebhookArgs{
		Name: pulumi.String("string"),
		Url:  pulumi.String("string"),
		Headers: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		Method: pulumi.String("string"),
		QueryParameters: pulumi.StringMap{
			"string": pulumi.String("string"),
		},
		Template:      pulumi.String("string"),
		WebhookSecret: pulumi.String("string"),
		WebhookType:   pulumi.String("string"),
	},
})

var alertChannelResource = new AlertChannel("alertChannelResource", AlertChannelArgs.builder()
    .call(AlertChannelCallArgs.builder()
        .name("string")
        .number("string")
        .build())
    .email(AlertChannelEmailArgs.builder()
        .address("string")
        .build())
    .opsgenie(AlertChannelOpsgenieArgs.builder()
        .apiKey("string")
        .name("string")
        .priority("string")
        .region("string")
        .build())
    .pagerduty(AlertChannelPagerdutyArgs.builder()
        .serviceKey("string")
        .account("string")
        .serviceName("string")
        .build())
    .sendDegraded(false)
    .sendFailure(false)
    .sendRecovery(false)
    .slack(AlertChannelSlackArgs.builder()
        .channel("string")
        .url("string")
        .build())
    .sms(AlertChannelSmsArgs.builder()
        .name("string")
        .number("string")
        .build())
    .sslExpiry(false)
    .sslExpiryThreshold(0)
    .webhook(AlertChannelWebhookArgs.builder()
        .name("string")
        .url("string")
        .headers(Map.of("string", "string"))
        .method("string")
        .queryParameters(Map.of("string", "string"))
        .template("string")
        .webhookSecret("string")
        .webhookType("string")
        .build())
    .build());

alert_channel_resource = checkly.AlertChannel("alertChannelResource",
    call={
        "name": "string",
        "number": "string",
    },
    email={
        "address": "string",
    },
    opsgenie={
        "api_key": "string",
        "name": "string",
        "priority": "string",
        "region": "string",
    },
    pagerduty={
        "service_key": "string",
        "account": "string",
        "service_name": "string",
    },
    send_degraded=False,
    send_failure=False,
    send_recovery=False,
    slack={
        "channel": "string",
        "url": "string",
    },
    sms={
        "name": "string",
        "number": "string",
    },
    ssl_expiry=False,
    ssl_expiry_threshold=0,
    webhook={
        "name": "string",
        "url": "string",
        "headers": {
            "string": "string",
        },
        "method": "string",
        "query_parameters": {
            "string": "string",
        },
        "template": "string",
        "webhook_secret": "string",
        "webhook_type": "string",
    })

const alertChannelResource = new checkly.AlertChannel("alertChannelResource", {
    call: {
        name: "string",
        number: "string",
    },
    email: {
        address: "string",
    },
    opsgenie: {
        apiKey: "string",
        name: "string",
        priority: "string",
        region: "string",
    },
    pagerduty: {
        serviceKey: "string",
        account: "string",
        serviceName: "string",
    },
    sendDegraded: false,
    sendFailure: false,
    sendRecovery: false,
    slack: {
        channel: "string",
        url: "string",
    },
    sms: {
        name: "string",
        number: "string",
    },
    sslExpiry: false,
    sslExpiryThreshold: 0,
    webhook: {
        name: "string",
        url: "string",
        headers: {
            string: "string",
        },
        method: "string",
        queryParameters: {
            string: "string",
        },
        template: "string",
        webhookSecret: "string",
        webhookType: "string",
    },
});

type: checkly:AlertChannel
properties:
    call:
        name: string
        number: string
    email:
        address: string
    opsgenie:
        apiKey: string
        name: string
        priority: string
        region: string
    pagerduty:
        account: string
        serviceKey: string
        serviceName: string
    sendDegraded: false
    sendFailure: false
    sendRecovery: false
    slack:
        channel: string
        url: string
    sms:
        name: string
        number: string
    sslExpiry: false
    sslExpiryThreshold: 0
    webhook:
        headers:
            string: string
        method: string
        name: string
        queryParameters:
            string: string
        template: string
        url: string
        webhookSecret: string
        webhookType: string