auth0.Guardian

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

return await Deployment.RunAsync(() => 
{
    var myGuardian = new Auth0.Guardian("myGuardian", new()
    {
        Duo = new Auth0.Inputs.GuardianDuoArgs
        {
            Enabled = true,
            Hostname = "api-hostname",
            IntegrationKey = "someKey",
            SecretKey = "someSecret",
        },
        Email = true,
        Otp = true,
        Phone = new Auth0.Inputs.GuardianPhoneArgs
        {
            Enabled = true,
            MessageTypes = new[]
            {
                "sms",
                "voice",
            },
            Options = new Auth0.Inputs.GuardianPhoneOptionsArgs
            {
                EnrollmentMessage = "{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment.",
                VerificationMessage = "{{code}} is your verification code for {{tenant.friendly_name}}.",
            },
            Provider = "auth0",
        },
        Policy = "all-applications",
        Push = new Auth0.Inputs.GuardianPushArgs
        {
            AmazonSns = new Auth0.Inputs.GuardianPushAmazonSnsArgs
            {
                AwsAccessKeyId = "test1",
                AwsRegion = "us-west-1",
                AwsSecretAccessKey = "secretKey",
                SnsApnsPlatformApplicationArn = "test_arn",
                SnsGcmPlatformApplicationArn = "test_arn",
            },
            CustomApp = new Auth0.Inputs.GuardianPushCustomAppArgs
            {
                AppName = "CustomApp",
                AppleAppLink = "https://itunes.apple.com/us/app/my-app/id123121",
                GoogleAppLink = "https://play.google.com/store/apps/details?id=com.my.app",
            },
            Enabled = true,
            Provider = "sns",
        },
        RecoveryCode = true,
        WebauthnPlatform = new Auth0.Inputs.GuardianWebauthnPlatformArgs
        {
            Enabled = true,
        },
        WebauthnRoaming = new Auth0.Inputs.GuardianWebauthnRoamingArgs
        {
            Enabled = true,
            UserVerification = "required",
        },
    });

});

package main

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

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := auth0.NewGuardian(ctx, "myGuardian", &auth0.GuardianArgs{
			Duo: &auth0.GuardianDuoArgs{
				Enabled:        pulumi.Bool(true),
				Hostname:       pulumi.String("api-hostname"),
				IntegrationKey: pulumi.String("someKey"),
				SecretKey:      pulumi.String("someSecret"),
			},
			Email: pulumi.Bool(true),
			Otp:   pulumi.Bool(true),
			Phone: &auth0.GuardianPhoneArgs{
				Enabled: pulumi.Bool(true),
				MessageTypes: pulumi.StringArray{
					pulumi.String("sms"),
					pulumi.String("voice"),
				},
				Options: &auth0.GuardianPhoneOptionsArgs{
					EnrollmentMessage:   pulumi.String("{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment."),
					VerificationMessage: pulumi.String("{{code}} is your verification code for {{tenant.friendly_name}}."),
				},
				Provider: pulumi.String("auth0"),
			},
			Policy: pulumi.String("all-applications"),
			Push: &auth0.GuardianPushArgs{
				AmazonSns: &auth0.GuardianPushAmazonSnsArgs{
					AwsAccessKeyId:                pulumi.String("test1"),
					AwsRegion:                     pulumi.String("us-west-1"),
					AwsSecretAccessKey:            pulumi.String("secretKey"),
					SnsApnsPlatformApplicationArn: pulumi.String("test_arn"),
					SnsGcmPlatformApplicationArn:  pulumi.String("test_arn"),
				},
				CustomApp: &auth0.GuardianPushCustomAppArgs{
					AppName:       pulumi.String("CustomApp"),
					AppleAppLink:  pulumi.String("https://itunes.apple.com/us/app/my-app/id123121"),
					GoogleAppLink: pulumi.String("https://play.google.com/store/apps/details?id=com.my.app"),
				},
				Enabled:  pulumi.Bool(true),
				Provider: pulumi.String("sns"),
			},
			RecoveryCode: pulumi.Bool(true),
			WebauthnPlatform: &auth0.GuardianWebauthnPlatformArgs{
				Enabled: pulumi.Bool(true),
			},
			WebauthnRoaming: &auth0.GuardianWebauthnRoamingArgs{
				Enabled:          pulumi.Bool(true),
				UserVerification: pulumi.String("required"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.auth0.Guardian;
import com.pulumi.auth0.GuardianArgs;
import com.pulumi.auth0.inputs.GuardianDuoArgs;
import com.pulumi.auth0.inputs.GuardianPhoneArgs;
import com.pulumi.auth0.inputs.GuardianPhoneOptionsArgs;
import com.pulumi.auth0.inputs.GuardianPushArgs;
import com.pulumi.auth0.inputs.GuardianPushAmazonSnsArgs;
import com.pulumi.auth0.inputs.GuardianPushCustomAppArgs;
import com.pulumi.auth0.inputs.GuardianWebauthnPlatformArgs;
import com.pulumi.auth0.inputs.GuardianWebauthnRoamingArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        var myGuardian = new Guardian("myGuardian", GuardianArgs.builder()        
            .duo(GuardianDuoArgs.builder()
                .enabled(true)
                .hostname("api-hostname")
                .integrationKey("someKey")
                .secretKey("someSecret")
                .build())
            .email(true)
            .otp(true)
            .phone(GuardianPhoneArgs.builder()
                .enabled(true)
                .messageTypes(                
                    "sms",
                    "voice")
                .options(GuardianPhoneOptionsArgs.builder()
                    .enrollmentMessage("{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment.")
                    .verificationMessage("{{code}} is your verification code for {{tenant.friendly_name}}.")
                    .build())
                .provider("auth0")
                .build())
            .policy("all-applications")
            .push(GuardianPushArgs.builder()
                .amazonSns(GuardianPushAmazonSnsArgs.builder()
                    .awsAccessKeyId("test1")
                    .awsRegion("us-west-1")
                    .awsSecretAccessKey("secretKey")
                    .snsApnsPlatformApplicationArn("test_arn")
                    .snsGcmPlatformApplicationArn("test_arn")
                    .build())
                .customApp(GuardianPushCustomAppArgs.builder()
                    .appName("CustomApp")
                    .appleAppLink("https://itunes.apple.com/us/app/my-app/id123121")
                    .googleAppLink("https://play.google.com/store/apps/details?id=com.my.app")
                    .build())
                .enabled(true)
                .provider("sns")
                .build())
            .recoveryCode(true)
            .webauthnPlatform(GuardianWebauthnPlatformArgs.builder()
                .enabled(true)
                .build())
            .webauthnRoaming(GuardianWebauthnRoamingArgs.builder()
                .enabled(true)
                .userVerification("required")
                .build())
            .build());

    }
}

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

const myGuardian = new auth0.Guardian("myGuardian", {
    duo: {
        enabled: true,
        hostname: "api-hostname",
        integrationKey: "someKey",
        secretKey: "someSecret",
    },
    email: true,
    otp: true,
    phone: {
        enabled: true,
        messageTypes: [
            "sms",
            "voice",
        ],
        options: {
            enrollmentMessage: "{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment.",
            verificationMessage: "{{code}} is your verification code for {{tenant.friendly_name}}.",
        },
        provider: "auth0",
    },
    policy: "all-applications",
    push: {
        amazonSns: {
            awsAccessKeyId: "test1",
            awsRegion: "us-west-1",
            awsSecretAccessKey: "secretKey",
            snsApnsPlatformApplicationArn: "test_arn",
            snsGcmPlatformApplicationArn: "test_arn",
        },
        customApp: {
            appName: "CustomApp",
            appleAppLink: "https://itunes.apple.com/us/app/my-app/id123121",
            googleAppLink: "https://play.google.com/store/apps/details?id=com.my.app",
        },
        enabled: true,
        provider: "sns",
    },
    recoveryCode: true,
    webauthnPlatform: {
        enabled: true,
    },
    webauthnRoaming: {
        enabled: true,
        userVerification: "required",
    },
});

import pulumi
import pulumi_auth0 as auth0

my_guardian = auth0.Guardian("myGuardian",
    duo=auth0.GuardianDuoArgs(
        enabled=True,
        hostname="api-hostname",
        integration_key="someKey",
        secret_key="someSecret",
    ),
    email=True,
    otp=True,
    phone=auth0.GuardianPhoneArgs(
        enabled=True,
        message_types=[
            "sms",
            "voice",
        ],
        options=auth0.GuardianPhoneOptionsArgs(
            enrollment_message="{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment.",
            verification_message="{{code}} is your verification code for {{tenant.friendly_name}}.",
        ),
        provider="auth0",
    ),
    policy="all-applications",
    push=auth0.GuardianPushArgs(
        amazon_sns=auth0.GuardianPushAmazonSnsArgs(
            aws_access_key_id="test1",
            aws_region="us-west-1",
            aws_secret_access_key="secretKey",
            sns_apns_platform_application_arn="test_arn",
            sns_gcm_platform_application_arn="test_arn",
        ),
        custom_app=auth0.GuardianPushCustomAppArgs(
            app_name="CustomApp",
            apple_app_link="https://itunes.apple.com/us/app/my-app/id123121",
            google_app_link="https://play.google.com/store/apps/details?id=com.my.app",
        ),
        enabled=True,
        provider="sns",
    ),
    recovery_code=True,
    webauthn_platform=auth0.GuardianWebauthnPlatformArgs(
        enabled=True,
    ),
    webauthn_roaming=auth0.GuardianWebauthnRoamingArgs(
        enabled=True,
        user_verification="required",
    ))

resources:
  myGuardian:
    type: auth0:Guardian
    properties:
      duo:
        enabled: true
        hostname: api-hostname
        integrationKey: someKey
        secretKey: someSecret
      email: true
      otp: true
      phone:
        enabled: true
        messageTypes:
          - sms
          - voice
        options:
          enrollmentMessage: '{{code}} is your verification code for {{tenant.friendly_name}}. Please enter this code to verify your enrollment.'
          verificationMessage: '{{code}} is your verification code for {{tenant.friendly_name}}.'
        provider: auth0
      policy: all-applications
      push:
        amazonSns:
          awsAccessKeyId: test1
          awsRegion: us-west-1
          awsSecretAccessKey: secretKey
          snsApnsPlatformApplicationArn: test_arn
          snsGcmPlatformApplicationArn: test_arn
        customApp:
          appName: CustomApp
          appleAppLink: https://itunes.apple.com/us/app/my-app/id123121
          googleAppLink: https://play.google.com/store/apps/details?id=com.my.app
        enabled: true
        provider: sns
      recoveryCode: true
      webauthnPlatform:
        enabled: true
      webauthnRoaming:
        enabled: true
        userVerification: required