aws.lex.Intent

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

const orderFlowersIntent = new aws.lex.Intent("order_flowers_intent", {
    confirmationPrompt: {
        maxAttempts: 2,
        messages: [{
            content: "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?",
            contentType: "PlainText",
        }],
    },
    createVersion: false,
    name: "OrderFlowers",
    description: "Intent to order a bouquet of flowers for pick up",
    fulfillmentActivity: {
        type: "ReturnIntent",
    },
    rejectionStatement: {
        messages: [{
            content: "Okay, I will not place your order.",
            contentType: "PlainText",
        }],
    },
    sampleUtterances: [
        "I would like to order some flowers",
        "I would like to pick up flowers",
    ],
    slots: [
        {
            description: "The type of flowers to pick up",
            name: "FlowerType",
            priority: 1,
            sampleUtterances: ["I would like to order {FlowerType}"],
            slotConstraint: "Required",
            slotType: "FlowerTypes",
            slotTypeVersion: "$$LATEST",
            valueElicitationPrompt: {
                maxAttempts: 2,
                messages: [{
                    content: "What type of flowers would you like to order?",
                    contentType: "PlainText",
                }],
            },
        },
        {
            description: "The date to pick up the flowers",
            name: "PickupDate",
            priority: 2,
            sampleUtterances: ["I would like to order {FlowerType}"],
            slotConstraint: "Required",
            slotType: "AMAZON.DATE",
            slotTypeVersion: "$$LATEST",
            valueElicitationPrompt: {
                maxAttempts: 2,
                messages: [{
                    content: "What day do you want the {FlowerType} to be picked up?",
                    contentType: "PlainText",
                }],
            },
        },
        {
            description: "The time to pick up the flowers",
            name: "PickupTime",
            priority: 3,
            sampleUtterances: ["I would like to order {FlowerType}"],
            slotConstraint: "Required",
            slotType: "AMAZON.TIME",
            slotTypeVersion: "$$LATEST",
            valueElicitationPrompt: {
                maxAttempts: 2,
                messages: [{
                    content: "Pick up the {FlowerType} at what time on {PickupDate}?",
                    contentType: "PlainText",
                }],
            },
        },
    ],
});

import pulumi
import pulumi_aws as aws

order_flowers_intent = aws.lex.Intent("order_flowers_intent",
    confirmation_prompt={
        "max_attempts": 2,
        "messages": [{
            "content": "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?",
            "content_type": "PlainText",
        }],
    },
    create_version=False,
    name="OrderFlowers",
    description="Intent to order a bouquet of flowers for pick up",
    fulfillment_activity={
        "type": "ReturnIntent",
    },
    rejection_statement={
        "messages": [{
            "content": "Okay, I will not place your order.",
            "content_type": "PlainText",
        }],
    },
    sample_utterances=[
        "I would like to order some flowers",
        "I would like to pick up flowers",
    ],
    slots=[
        {
            "description": "The type of flowers to pick up",
            "name": "FlowerType",
            "priority": 1,
            "sample_utterances": ["I would like to order {FlowerType}"],
            "slot_constraint": "Required",
            "slot_type": "FlowerTypes",
            "slot_type_version": "$$LATEST",
            "value_elicitation_prompt": {
                "max_attempts": 2,
                "messages": [{
                    "content": "What type of flowers would you like to order?",
                    "content_type": "PlainText",
                }],
            },
        },
        {
            "description": "The date to pick up the flowers",
            "name": "PickupDate",
            "priority": 2,
            "sample_utterances": ["I would like to order {FlowerType}"],
            "slot_constraint": "Required",
            "slot_type": "AMAZON.DATE",
            "slot_type_version": "$$LATEST",
            "value_elicitation_prompt": {
                "max_attempts": 2,
                "messages": [{
                    "content": "What day do you want the {FlowerType} to be picked up?",
                    "content_type": "PlainText",
                }],
            },
        },
        {
            "description": "The time to pick up the flowers",
            "name": "PickupTime",
            "priority": 3,
            "sample_utterances": ["I would like to order {FlowerType}"],
            "slot_constraint": "Required",
            "slot_type": "AMAZON.TIME",
            "slot_type_version": "$$LATEST",
            "value_elicitation_prompt": {
                "max_attempts": 2,
                "messages": [{
                    "content": "Pick up the {FlowerType} at what time on {PickupDate}?",
                    "content_type": "PlainText",
                }],
            },
        },
    ])

package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v6/go/aws/lex"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := lex.NewIntent(ctx, "order_flowers_intent", &lex.IntentArgs{
			ConfirmationPrompt: &lex.IntentConfirmationPromptArgs{
				MaxAttempts: pulumi.Int(2),
				Messages: lex.IntentConfirmationPromptMessageArray{
					&lex.IntentConfirmationPromptMessageArgs{
						Content:     pulumi.String("Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?"),
						ContentType: pulumi.String("PlainText"),
					},
				},
			},
			CreateVersion: pulumi.Bool(false),
			Name:          pulumi.String("OrderFlowers"),
			Description:   pulumi.String("Intent to order a bouquet of flowers for pick up"),
			FulfillmentActivity: &lex.IntentFulfillmentActivityArgs{
				Type: pulumi.String("ReturnIntent"),
			},
			RejectionStatement: &lex.IntentRejectionStatementArgs{
				Messages: lex.IntentRejectionStatementMessageArray{
					&lex.IntentRejectionStatementMessageArgs{
						Content:     pulumi.String("Okay, I will not place your order."),
						ContentType: pulumi.String("PlainText"),
					},
				},
			},
			SampleUtterances: pulumi.StringArray{
				pulumi.String("I would like to order some flowers"),
				pulumi.String("I would like to pick up flowers"),
			},
			Slots: lex.IntentSlotArray{
				&lex.IntentSlotArgs{
					Description: pulumi.String("The type of flowers to pick up"),
					Name:        pulumi.String("FlowerType"),
					Priority:    pulumi.Int(1),
					SampleUtterances: pulumi.StringArray{
						pulumi.String("I would like to order {FlowerType}"),
					},
					SlotConstraint:  pulumi.String("Required"),
					SlotType:        pulumi.String("FlowerTypes"),
					SlotTypeVersion: pulumi.String("$$LATEST"),
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						MaxAttempts: pulumi.Int(2),
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("What type of flowers would you like to order?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
					},
				},
				&lex.IntentSlotArgs{
					Description: pulumi.String("The date to pick up the flowers"),
					Name:        pulumi.String("PickupDate"),
					Priority:    pulumi.Int(2),
					SampleUtterances: pulumi.StringArray{
						pulumi.String("I would like to order {FlowerType}"),
					},
					SlotConstraint:  pulumi.String("Required"),
					SlotType:        pulumi.String("AMAZON.DATE"),
					SlotTypeVersion: pulumi.String("$$LATEST"),
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						MaxAttempts: pulumi.Int(2),
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("What day do you want the {FlowerType} to be picked up?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
					},
				},
				&lex.IntentSlotArgs{
					Description: pulumi.String("The time to pick up the flowers"),
					Name:        pulumi.String("PickupTime"),
					Priority:    pulumi.Int(3),
					SampleUtterances: pulumi.StringArray{
						pulumi.String("I would like to order {FlowerType}"),
					},
					SlotConstraint:  pulumi.String("Required"),
					SlotType:        pulumi.String("AMAZON.TIME"),
					SlotTypeVersion: pulumi.String("$$LATEST"),
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						MaxAttempts: pulumi.Int(2),
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("Pick up the {FlowerType} at what time on {PickupDate}?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
					},
				},
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

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

return await Deployment.RunAsync(() => 
{
    var orderFlowersIntent = new Aws.Lex.Intent("order_flowers_intent", new()
    {
        ConfirmationPrompt = new Aws.Lex.Inputs.IntentConfirmationPromptArgs
        {
            MaxAttempts = 2,
            Messages = new[]
            {
                new Aws.Lex.Inputs.IntentConfirmationPromptMessageArgs
                {
                    Content = "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?",
                    ContentType = "PlainText",
                },
            },
        },
        CreateVersion = false,
        Name = "OrderFlowers",
        Description = "Intent to order a bouquet of flowers for pick up",
        FulfillmentActivity = new Aws.Lex.Inputs.IntentFulfillmentActivityArgs
        {
            Type = "ReturnIntent",
        },
        RejectionStatement = new Aws.Lex.Inputs.IntentRejectionStatementArgs
        {
            Messages = new[]
            {
                new Aws.Lex.Inputs.IntentRejectionStatementMessageArgs
                {
                    Content = "Okay, I will not place your order.",
                    ContentType = "PlainText",
                },
            },
        },
        SampleUtterances = new[]
        {
            "I would like to order some flowers",
            "I would like to pick up flowers",
        },
        Slots = new[]
        {
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                Description = "The type of flowers to pick up",
                Name = "FlowerType",
                Priority = 1,
                SampleUtterances = new[]
                {
                    "I would like to order {FlowerType}",
                },
                SlotConstraint = "Required",
                SlotType = "FlowerTypes",
                SlotTypeVersion = "$$LATEST",
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    MaxAttempts = 2,
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "What type of flowers would you like to order?",
                            ContentType = "PlainText",
                        },
                    },
                },
            },
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                Description = "The date to pick up the flowers",
                Name = "PickupDate",
                Priority = 2,
                SampleUtterances = new[]
                {
                    "I would like to order {FlowerType}",
                },
                SlotConstraint = "Required",
                SlotType = "AMAZON.DATE",
                SlotTypeVersion = "$$LATEST",
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    MaxAttempts = 2,
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "What day do you want the {FlowerType} to be picked up?",
                            ContentType = "PlainText",
                        },
                    },
                },
            },
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                Description = "The time to pick up the flowers",
                Name = "PickupTime",
                Priority = 3,
                SampleUtterances = new[]
                {
                    "I would like to order {FlowerType}",
                },
                SlotConstraint = "Required",
                SlotType = "AMAZON.TIME",
                SlotTypeVersion = "$$LATEST",
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    MaxAttempts = 2,
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "Pick up the {FlowerType} at what time on {PickupDate}?",
                            ContentType = "PlainText",
                        },
                    },
                },
            },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.aws.lex.Intent;
import com.pulumi.aws.lex.IntentArgs;
import com.pulumi.aws.lex.inputs.IntentConfirmationPromptArgs;
import com.pulumi.aws.lex.inputs.IntentFulfillmentActivityArgs;
import com.pulumi.aws.lex.inputs.IntentRejectionStatementArgs;
import com.pulumi.aws.lex.inputs.IntentSlotArgs;
import com.pulumi.aws.lex.inputs.IntentSlotValueElicitationPromptArgs;
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 orderFlowersIntent = new Intent("orderFlowersIntent", IntentArgs.builder()
            .confirmationPrompt(IntentConfirmationPromptArgs.builder()
                .maxAttempts(2)
                .messages(IntentConfirmationPromptMessageArgs.builder()
                    .content("Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?")
                    .contentType("PlainText")
                    .build())
                .build())
            .createVersion(false)
            .name("OrderFlowers")
            .description("Intent to order a bouquet of flowers for pick up")
            .fulfillmentActivity(IntentFulfillmentActivityArgs.builder()
                .type("ReturnIntent")
                .build())
            .rejectionStatement(IntentRejectionStatementArgs.builder()
                .messages(IntentRejectionStatementMessageArgs.builder()
                    .content("Okay, I will not place your order.")
                    .contentType("PlainText")
                    .build())
                .build())
            .sampleUtterances(            
                "I would like to order some flowers",
                "I would like to pick up flowers")
            .slots(            
                IntentSlotArgs.builder()
                    .description("The type of flowers to pick up")
                    .name("FlowerType")
                    .priority(1)
                    .sampleUtterances("I would like to order {FlowerType}")
                    .slotConstraint("Required")
                    .slotType("FlowerTypes")
                    .slotTypeVersion("$$LATEST")
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .maxAttempts(2)
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("What type of flowers would you like to order?")
                            .contentType("PlainText")
                            .build())
                        .build())
                    .build(),
                IntentSlotArgs.builder()
                    .description("The date to pick up the flowers")
                    .name("PickupDate")
                    .priority(2)
                    .sampleUtterances("I would like to order {FlowerType}")
                    .slotConstraint("Required")
                    .slotType("AMAZON.DATE")
                    .slotTypeVersion("$$LATEST")
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .maxAttempts(2)
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("What day do you want the {FlowerType} to be picked up?")
                            .contentType("PlainText")
                            .build())
                        .build())
                    .build(),
                IntentSlotArgs.builder()
                    .description("The time to pick up the flowers")
                    .name("PickupTime")
                    .priority(3)
                    .sampleUtterances("I would like to order {FlowerType}")
                    .slotConstraint("Required")
                    .slotType("AMAZON.TIME")
                    .slotTypeVersion("$$LATEST")
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .maxAttempts(2)
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("Pick up the {FlowerType} at what time on {PickupDate}?")
                            .contentType("PlainText")
                            .build())
                        .build())
                    .build())
            .build());

    }
}

resources:
  orderFlowersIntent:
    type: aws:lex:Intent
    name: order_flowers_intent
    properties:
      confirmationPrompt:
        maxAttempts: 2
        messages:
          - content: Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?
            contentType: PlainText
      createVersion: false
      name: OrderFlowers
      description: Intent to order a bouquet of flowers for pick up
      fulfillmentActivity:
        type: ReturnIntent
      rejectionStatement:
        messages:
          - content: Okay, I will not place your order.
            contentType: PlainText
      sampleUtterances:
        - I would like to order some flowers
        - I would like to pick up flowers
      slots:
        - description: The type of flowers to pick up
          name: FlowerType
          priority: 1
          sampleUtterances:
            - I would like to order {FlowerType}
          slotConstraint: Required
          slotType: FlowerTypes
          slotTypeVersion: $$LATEST
          valueElicitationPrompt:
            maxAttempts: 2
            messages:
              - content: What type of flowers would you like to order?
                contentType: PlainText
        - description: The date to pick up the flowers
          name: PickupDate
          priority: 2
          sampleUtterances:
            - I would like to order {FlowerType}
          slotConstraint: Required
          slotType: AMAZON.DATE
          slotTypeVersion: $$LATEST
          valueElicitationPrompt:
            maxAttempts: 2
            messages:
              - content: What day do you want the {FlowerType} to be picked up?
                contentType: PlainText
        - description: The time to pick up the flowers
          name: PickupTime
          priority: 3
          sampleUtterances:
            - I would like to order {FlowerType}
          slotConstraint: Required
          slotType: AMAZON.TIME
          slotTypeVersion: $$LATEST
          valueElicitationPrompt:
            maxAttempts: 2
            messages:
              - content: Pick up the {FlowerType} at what time on {PickupDate}?
                contentType: PlainText

var intentResource = new Aws.Lex.Intent("intentResource", new()
{
    FulfillmentActivity = new Aws.Lex.Inputs.IntentFulfillmentActivityArgs
    {
        Type = "string",
        CodeHook = new Aws.Lex.Inputs.IntentFulfillmentActivityCodeHookArgs
        {
            MessageVersion = "string",
            Uri = "string",
        },
    },
    ConclusionStatement = new Aws.Lex.Inputs.IntentConclusionStatementArgs
    {
        Messages = new[]
        {
            new Aws.Lex.Inputs.IntentConclusionStatementMessageArgs
            {
                Content = "string",
                ContentType = "string",
                GroupNumber = 0,
            },
        },
        ResponseCard = "string",
    },
    ConfirmationPrompt = new Aws.Lex.Inputs.IntentConfirmationPromptArgs
    {
        MaxAttempts = 0,
        Messages = new[]
        {
            new Aws.Lex.Inputs.IntentConfirmationPromptMessageArgs
            {
                Content = "string",
                ContentType = "string",
                GroupNumber = 0,
            },
        },
        ResponseCard = "string",
    },
    CreateVersion = false,
    Description = "string",
    DialogCodeHook = new Aws.Lex.Inputs.IntentDialogCodeHookArgs
    {
        MessageVersion = "string",
        Uri = "string",
    },
    FollowUpPrompt = new Aws.Lex.Inputs.IntentFollowUpPromptArgs
    {
        Prompt = new Aws.Lex.Inputs.IntentFollowUpPromptPromptArgs
        {
            MaxAttempts = 0,
            Messages = new[]
            {
                new Aws.Lex.Inputs.IntentFollowUpPromptPromptMessageArgs
                {
                    Content = "string",
                    ContentType = "string",
                    GroupNumber = 0,
                },
            },
            ResponseCard = "string",
        },
        RejectionStatement = new Aws.Lex.Inputs.IntentFollowUpPromptRejectionStatementArgs
        {
            Messages = new[]
            {
                new Aws.Lex.Inputs.IntentFollowUpPromptRejectionStatementMessageArgs
                {
                    Content = "string",
                    ContentType = "string",
                    GroupNumber = 0,
                },
            },
            ResponseCard = "string",
        },
    },
    Name = "string",
    ParentIntentSignature = "string",
    RejectionStatement = new Aws.Lex.Inputs.IntentRejectionStatementArgs
    {
        Messages = new[]
        {
            new Aws.Lex.Inputs.IntentRejectionStatementMessageArgs
            {
                Content = "string",
                ContentType = "string",
                GroupNumber = 0,
            },
        },
        ResponseCard = "string",
    },
    SampleUtterances = new[]
    {
        "string",
    },
    Slots = new[]
    {
        new Aws.Lex.Inputs.IntentSlotArgs
        {
            Name = "string",
            SlotConstraint = "string",
            SlotType = "string",
            Description = "string",
            Priority = 0,
            ResponseCard = "string",
            SampleUtterances = new[]
            {
                "string",
            },
            SlotTypeVersion = "string",
            ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
            {
                MaxAttempts = 0,
                Messages = new[]
                {
                    new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                    {
                        Content = "string",
                        ContentType = "string",
                        GroupNumber = 0,
                    },
                },
                ResponseCard = "string",
            },
        },
    },
});

example, err := lex.NewIntent(ctx, "intentResource", &lex.IntentArgs{
	FulfillmentActivity: &lex.IntentFulfillmentActivityArgs{
		Type: pulumi.String("string"),
		CodeHook: &lex.IntentFulfillmentActivityCodeHookArgs{
			MessageVersion: pulumi.String("string"),
			Uri:            pulumi.String("string"),
		},
	},
	ConclusionStatement: &lex.IntentConclusionStatementArgs{
		Messages: lex.IntentConclusionStatementMessageArray{
			&lex.IntentConclusionStatementMessageArgs{
				Content:     pulumi.String("string"),
				ContentType: pulumi.String("string"),
				GroupNumber: pulumi.Int(0),
			},
		},
		ResponseCard: pulumi.String("string"),
	},
	ConfirmationPrompt: &lex.IntentConfirmationPromptArgs{
		MaxAttempts: pulumi.Int(0),
		Messages: lex.IntentConfirmationPromptMessageArray{
			&lex.IntentConfirmationPromptMessageArgs{
				Content:     pulumi.String("string"),
				ContentType: pulumi.String("string"),
				GroupNumber: pulumi.Int(0),
			},
		},
		ResponseCard: pulumi.String("string"),
	},
	CreateVersion: pulumi.Bool(false),
	Description:   pulumi.String("string"),
	DialogCodeHook: &lex.IntentDialogCodeHookArgs{
		MessageVersion: pulumi.String("string"),
		Uri:            pulumi.String("string"),
	},
	FollowUpPrompt: &lex.IntentFollowUpPromptArgs{
		Prompt: &lex.IntentFollowUpPromptPromptArgs{
			MaxAttempts: pulumi.Int(0),
			Messages: lex.IntentFollowUpPromptPromptMessageArray{
				&lex.IntentFollowUpPromptPromptMessageArgs{
					Content:     pulumi.String("string"),
					ContentType: pulumi.String("string"),
					GroupNumber: pulumi.Int(0),
				},
			},
			ResponseCard: pulumi.String("string"),
		},
		RejectionStatement: &lex.IntentFollowUpPromptRejectionStatementArgs{
			Messages: lex.IntentFollowUpPromptRejectionStatementMessageArray{
				&lex.IntentFollowUpPromptRejectionStatementMessageArgs{
					Content:     pulumi.String("string"),
					ContentType: pulumi.String("string"),
					GroupNumber: pulumi.Int(0),
				},
			},
			ResponseCard: pulumi.String("string"),
		},
	},
	Name:                  pulumi.String("string"),
	ParentIntentSignature: pulumi.String("string"),
	RejectionStatement: &lex.IntentRejectionStatementArgs{
		Messages: lex.IntentRejectionStatementMessageArray{
			&lex.IntentRejectionStatementMessageArgs{
				Content:     pulumi.String("string"),
				ContentType: pulumi.String("string"),
				GroupNumber: pulumi.Int(0),
			},
		},
		ResponseCard: pulumi.String("string"),
	},
	SampleUtterances: pulumi.StringArray{
		pulumi.String("string"),
	},
	Slots: lex.IntentSlotArray{
		&lex.IntentSlotArgs{
			Name:           pulumi.String("string"),
			SlotConstraint: pulumi.String("string"),
			SlotType:       pulumi.String("string"),
			Description:    pulumi.String("string"),
			Priority:       pulumi.Int(0),
			ResponseCard:   pulumi.String("string"),
			SampleUtterances: pulumi.StringArray{
				pulumi.String("string"),
			},
			SlotTypeVersion: pulumi.String("string"),
			ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
				MaxAttempts: pulumi.Int(0),
				Messages: lex.IntentSlotValueElicitationPromptMessageArray{
					&lex.IntentSlotValueElicitationPromptMessageArgs{
						Content:     pulumi.String("string"),
						ContentType: pulumi.String("string"),
						GroupNumber: pulumi.Int(0),
					},
				},
				ResponseCard: pulumi.String("string"),
			},
		},
	},
})

var intentResource = new Intent("intentResource", IntentArgs.builder()
    .fulfillmentActivity(IntentFulfillmentActivityArgs.builder()
        .type("string")
        .codeHook(IntentFulfillmentActivityCodeHookArgs.builder()
            .messageVersion("string")
            .uri("string")
            .build())
        .build())
    .conclusionStatement(IntentConclusionStatementArgs.builder()
        .messages(IntentConclusionStatementMessageArgs.builder()
            .content("string")
            .contentType("string")
            .groupNumber(0)
            .build())
        .responseCard("string")
        .build())
    .confirmationPrompt(IntentConfirmationPromptArgs.builder()
        .maxAttempts(0)
        .messages(IntentConfirmationPromptMessageArgs.builder()
            .content("string")
            .contentType("string")
            .groupNumber(0)
            .build())
        .responseCard("string")
        .build())
    .createVersion(false)
    .description("string")
    .dialogCodeHook(IntentDialogCodeHookArgs.builder()
        .messageVersion("string")
        .uri("string")
        .build())
    .followUpPrompt(IntentFollowUpPromptArgs.builder()
        .prompt(IntentFollowUpPromptPromptArgs.builder()
            .maxAttempts(0)
            .messages(IntentFollowUpPromptPromptMessageArgs.builder()
                .content("string")
                .contentType("string")
                .groupNumber(0)
                .build())
            .responseCard("string")
            .build())
        .rejectionStatement(IntentFollowUpPromptRejectionStatementArgs.builder()
            .messages(IntentFollowUpPromptRejectionStatementMessageArgs.builder()
                .content("string")
                .contentType("string")
                .groupNumber(0)
                .build())
            .responseCard("string")
            .build())
        .build())
    .name("string")
    .parentIntentSignature("string")
    .rejectionStatement(IntentRejectionStatementArgs.builder()
        .messages(IntentRejectionStatementMessageArgs.builder()
            .content("string")
            .contentType("string")
            .groupNumber(0)
            .build())
        .responseCard("string")
        .build())
    .sampleUtterances("string")
    .slots(IntentSlotArgs.builder()
        .name("string")
        .slotConstraint("string")
        .slotType("string")
        .description("string")
        .priority(0)
        .responseCard("string")
        .sampleUtterances("string")
        .slotTypeVersion("string")
        .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
            .maxAttempts(0)
            .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                .content("string")
                .contentType("string")
                .groupNumber(0)
                .build())
            .responseCard("string")
            .build())
        .build())
    .build());

intent_resource = aws.lex.Intent("intentResource",
    fulfillment_activity={
        "type": "string",
        "codeHook": {
            "messageVersion": "string",
            "uri": "string",
        },
    },
    conclusion_statement={
        "messages": [{
            "content": "string",
            "contentType": "string",
            "groupNumber": 0,
        }],
        "responseCard": "string",
    },
    confirmation_prompt={
        "maxAttempts": 0,
        "messages": [{
            "content": "string",
            "contentType": "string",
            "groupNumber": 0,
        }],
        "responseCard": "string",
    },
    create_version=False,
    description="string",
    dialog_code_hook={
        "messageVersion": "string",
        "uri": "string",
    },
    follow_up_prompt={
        "prompt": {
            "maxAttempts": 0,
            "messages": [{
                "content": "string",
                "contentType": "string",
                "groupNumber": 0,
            }],
            "responseCard": "string",
        },
        "rejectionStatement": {
            "messages": [{
                "content": "string",
                "contentType": "string",
                "groupNumber": 0,
            }],
            "responseCard": "string",
        },
    },
    name="string",
    parent_intent_signature="string",
    rejection_statement={
        "messages": [{
            "content": "string",
            "contentType": "string",
            "groupNumber": 0,
        }],
        "responseCard": "string",
    },
    sample_utterances=["string"],
    slots=[{
        "name": "string",
        "slotConstraint": "string",
        "slotType": "string",
        "description": "string",
        "priority": 0,
        "responseCard": "string",
        "sampleUtterances": ["string"],
        "slotTypeVersion": "string",
        "valueElicitationPrompt": {
            "maxAttempts": 0,
            "messages": [{
                "content": "string",
                "contentType": "string",
                "groupNumber": 0,
            }],
            "responseCard": "string",
        },
    }])

const intentResource = new aws.lex.Intent("intentResource", {
    fulfillmentActivity: {
        type: "string",
        codeHook: {
            messageVersion: "string",
            uri: "string",
        },
    },
    conclusionStatement: {
        messages: [{
            content: "string",
            contentType: "string",
            groupNumber: 0,
        }],
        responseCard: "string",
    },
    confirmationPrompt: {
        maxAttempts: 0,
        messages: [{
            content: "string",
            contentType: "string",
            groupNumber: 0,
        }],
        responseCard: "string",
    },
    createVersion: false,
    description: "string",
    dialogCodeHook: {
        messageVersion: "string",
        uri: "string",
    },
    followUpPrompt: {
        prompt: {
            maxAttempts: 0,
            messages: [{
                content: "string",
                contentType: "string",
                groupNumber: 0,
            }],
            responseCard: "string",
        },
        rejectionStatement: {
            messages: [{
                content: "string",
                contentType: "string",
                groupNumber: 0,
            }],
            responseCard: "string",
        },
    },
    name: "string",
    parentIntentSignature: "string",
    rejectionStatement: {
        messages: [{
            content: "string",
            contentType: "string",
            groupNumber: 0,
        }],
        responseCard: "string",
    },
    sampleUtterances: ["string"],
    slots: [{
        name: "string",
        slotConstraint: "string",
        slotType: "string",
        description: "string",
        priority: 0,
        responseCard: "string",
        sampleUtterances: ["string"],
        slotTypeVersion: "string",
        valueElicitationPrompt: {
            maxAttempts: 0,
            messages: [{
                content: "string",
                contentType: "string",
                groupNumber: 0,
            }],
            responseCard: "string",
        },
    }],
});

type: aws:lex:Intent
properties:
    conclusionStatement:
        messages:
            - content: string
              contentType: string
              groupNumber: 0
        responseCard: string
    confirmationPrompt:
        maxAttempts: 0
        messages:
            - content: string
              contentType: string
              groupNumber: 0
        responseCard: string
    createVersion: false
    description: string
    dialogCodeHook:
        messageVersion: string
        uri: string
    followUpPrompt:
        prompt:
            maxAttempts: 0
            messages:
                - content: string
                  contentType: string
                  groupNumber: 0
            responseCard: string
        rejectionStatement:
            messages:
                - content: string
                  contentType: string
                  groupNumber: 0
            responseCard: string
    fulfillmentActivity:
        codeHook:
            messageVersion: string
            uri: string
        type: string
    name: string
    parentIntentSignature: string
    rejectionStatement:
        messages:
            - content: string
              contentType: string
              groupNumber: 0
        responseCard: string
    sampleUtterances:
        - string
    slots:
        - description: string
          name: string
          priority: 0
          responseCard: string
          sampleUtterances:
            - string
          slotConstraint: string
          slotType: string
          slotTypeVersion: string
          valueElicitationPrompt:
            maxAttempts: 0
            messages:
                - content: string
                  contentType: string
                  groupNumber: 0
            responseCard: string