Intent class

Provides an Amazon Lex Intent resource. For more information see Amazon Lex: How It Works

Example Usage

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

const orderFlowersIntent = new aws.lex.Intent("order_flowers_intent", {
    confirmationPrompt: {
        messages: [{
            content: "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?",
            contentType: "PlainText",
        }],
        maxAttempts: 2,
    },
    fulfillmentActivity: {
        type: "ReturnIntent",
    },
    rejectionStatement: {
        messages: [{
            content: "Okay, I will not place your order.",
            contentType: "PlainText",
        }],
    },
    slots: [
        {
            valueElicitationPrompt: {
                messages: [{
                    content: "What type of flowers would you like to order?",
                    contentType: "PlainText",
                }],
                maxAttempts: 2,
            },
            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: {
                messages: [{
                    content: "What day do you want the {FlowerType} to be picked up?",
                    contentType: "PlainText",
                }],
                maxAttempts: 2,
            },
            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: {
                messages: [{
                    content: "Pick up the {FlowerType} at what time on {PickupDate}?",
                    contentType: "PlainText",
                }],
                maxAttempts: 2,
            },
            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",
        },
    ],
    createVersion: false,
    name: "OrderFlowers",
    description: "Intent to order a bouquet of flowers for pick up",
    sampleUtterances: [
        "I would like to order some flowers",
        "I would like to pick up flowers",
    ],
});
import pulumi
import pulumi_aws as aws

order_flowers_intent = aws.lex.Intent("order_flowers_intent",
    confirmation_prompt={
        "messages": [{
            "content": "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?",
            "content_type": "PlainText",
        }],
        "max_attempts": 2,
    },
    fulfillment_activity={
        "type": "ReturnIntent",
    },
    rejection_statement={
        "messages": [{
            "content": "Okay, I will not place your order.",
            "content_type": "PlainText",
        }],
    },
    slots=[
        {
            "value_elicitation_prompt": {
                "messages": [{
                    "content": "What type of flowers would you like to order?",
                    "content_type": "PlainText",
                }],
                "max_attempts": 2,
            },
            "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": {
                "messages": [{
                    "content": "What day do you want the {FlowerType} to be picked up?",
                    "content_type": "PlainText",
                }],
                "max_attempts": 2,
            },
            "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": {
                "messages": [{
                    "content": "Pick up the {FlowerType} at what time on {PickupDate}?",
                    "content_type": "PlainText",
                }],
                "max_attempts": 2,
            },
            "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",
        },
    ],
    create_version=False,
    name="OrderFlowers",
    description="Intent to order a bouquet of flowers for pick up",
    sample_utterances=[
        "I would like to order some flowers",
        "I would like to pick up flowers",
    ])
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
        {
            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",
                },
            },
            MaxAttempts = 2,
        },
        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",
                },
            },
        },
        Slots = new[]
        {
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "What type of flowers would you like to order?",
                            ContentType = "PlainText",
                        },
                    },
                    MaxAttempts = 2,
                },
                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",
            },
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "What day do you want the {FlowerType} to be picked up?",
                            ContentType = "PlainText",
                        },
                    },
                    MaxAttempts = 2,
                },
                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",
            },
            new Aws.Lex.Inputs.IntentSlotArgs
            {
                ValueElicitationPrompt = new Aws.Lex.Inputs.IntentSlotValueElicitationPromptArgs
                {
                    Messages = new[]
                    {
                        new Aws.Lex.Inputs.IntentSlotValueElicitationPromptMessageArgs
                        {
                            Content = "Pick up the {FlowerType} at what time on {PickupDate}?",
                            ContentType = "PlainText",
                        },
                    },
                    MaxAttempts = 2,
                },
                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",
            },
        },
        CreateVersion = false,
        Name = "OrderFlowers",
        Description = "Intent to order a bouquet of flowers for pick up",
        SampleUtterances = new[]
        {
            "I would like to order some flowers",
            "I would like to pick up flowers",
        },
    });

});
package main

import (
	"github.com/pulumi/pulumi-aws/sdk/v7/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{
				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"),
					},
				},
				MaxAttempts: pulumi.Int(2),
			},
			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"),
					},
				},
			},
			Slots: lex.IntentSlotArray{
				&lex.IntentSlotArgs{
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("What type of flowers would you like to order?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
						MaxAttempts: pulumi.Int(2),
					},
					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"),
				},
				&lex.IntentSlotArgs{
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("What day do you want the {FlowerType} to be picked up?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
						MaxAttempts: pulumi.Int(2),
					},
					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"),
				},
				&lex.IntentSlotArgs{
					ValueElicitationPrompt: &lex.IntentSlotValueElicitationPromptArgs{
						Messages: lex.IntentSlotValueElicitationPromptMessageArray{
							&lex.IntentSlotValueElicitationPromptMessageArgs{
								Content:     pulumi.String("Pick up the {FlowerType} at what time on {PickupDate}?"),
								ContentType: pulumi.String("PlainText"),
							},
						},
						MaxAttempts: pulumi.Int(2),
					},
					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"),
				},
			},
			CreateVersion: pulumi.Bool(false),
			Name:          pulumi.String("OrderFlowers"),
			Description:   pulumi.String("Intent to order a bouquet of flowers for pick up"),
			SampleUtterances: pulumi.StringArray{
				pulumi.String("I would like to order some flowers"),
				pulumi.String("I would like to pick up flowers"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
pulumi {
  required_providers {
    aws = {
      source = "pulumi/aws"
    }
  }
}

resource "aws_lex_intent" "order_flowers_intent" {
  confirmation_prompt = {
    messages = [{
      "content"     = "Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?"
      "contentType" = "PlainText"
    }]
    max_attempts = 2
  }
  fulfillment_activity = {
    type = "ReturnIntent"
  }
  rejection_statement = {
    messages = [{
      "content"     = "Okay, I will not place your order."
      "contentType" = "PlainText"
    }]
  }
  slots {
    value_elicitation_prompt = {
      messages = [{
        "content"     = "What type of flowers would you like to order?"
        "contentType" = "PlainText"
      }]
      max_attempts = 2
    }
    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"
  }
  slots {
    value_elicitation_prompt = {
      messages = [{
        "content"     = "What day do you want the {FlowerType} to be picked up?"
        "contentType" = "PlainText"
      }]
      max_attempts = 2
    }
    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"
  }
  slots {
    value_elicitation_prompt = {
      messages = [{
        "content"     = "Pick up the {FlowerType} at what time on {PickupDate}?"
        "contentType" = "PlainText"
      }]
      max_attempts = 2
    }
    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"
  }
  create_version    = false
  name              = "OrderFlowers"
  description       = "Intent to order a bouquet of flowers for pick up"
  sample_utterances = ["I would like to order some flowers", "I would like to pick up flowers"]
}
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.IntentConfirmationPromptMessageArgs;
import com.pulumi.aws.lex.inputs.IntentFulfillmentActivityArgs;
import com.pulumi.aws.lex.inputs.IntentRejectionStatementArgs;
import com.pulumi.aws.lex.inputs.IntentRejectionStatementMessageArgs;
import com.pulumi.aws.lex.inputs.IntentSlotArgs;
import com.pulumi.aws.lex.inputs.IntentSlotValueElicitationPromptArgs;
import com.pulumi.aws.lex.inputs.IntentSlotValueElicitationPromptMessageArgs;
import java.util.ArrayList;
import java.util.Arrays;
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()
                .messages(IntentConfirmationPromptMessageArgs.builder()
                    .content("Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?")
                    .contentType("PlainText")
                    .build())
                .maxAttempts(2)
                .build())
            .fulfillmentActivity(IntentFulfillmentActivityArgs.builder()
                .type("ReturnIntent")
                .build())
            .rejectionStatement(IntentRejectionStatementArgs.builder()
                .messages(IntentRejectionStatementMessageArgs.builder()
                    .content("Okay, I will not place your order.")
                    .contentType("PlainText")
                    .build())
                .build())
            .slots(
                IntentSlotArgs.builder()
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("What type of flowers would you like to order?")
                            .contentType("PlainText")
                            .build())
                        .maxAttempts(2)
                        .build())
                    .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")
                    .build(),
                IntentSlotArgs.builder()
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("What day do you want the {FlowerType} to be picked up?")
                            .contentType("PlainText")
                            .build())
                        .maxAttempts(2)
                        .build())
                    .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")
                    .build(),
                IntentSlotArgs.builder()
                    .valueElicitationPrompt(IntentSlotValueElicitationPromptArgs.builder()
                        .messages(IntentSlotValueElicitationPromptMessageArgs.builder()
                            .content("Pick up the {FlowerType} at what time on {PickupDate}?")
                            .contentType("PlainText")
                            .build())
                        .maxAttempts(2)
                        .build())
                    .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")
                    .build())
            .createVersion(false)
            .name("OrderFlowers")
            .description("Intent to order a bouquet of flowers for pick up")
            .sampleUtterances(
                "I would like to order some flowers",
                "I would like to pick up flowers")
            .build());

    }
}
resources:
  orderFlowersIntent:
    type: aws:lex:Intent
    name: order_flowers_intent
    properties:
      confirmationPrompt:
        messages:
          - content: Okay, your {FlowerType} will be ready for pickup by {PickupTime} on {PickupDate}.  Does this sound okay?
            contentType: PlainText
        maxAttempts: 2
      fulfillmentActivity:
        type: ReturnIntent
      rejectionStatement:
        messages:
          - content: Okay, I will not place your order.
            contentType: PlainText
      slots:
        - valueElicitationPrompt:
            messages:
              - content: What type of flowers would you like to order?
                contentType: PlainText
            maxAttempts: 2
          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:
            messages:
              - content: What day do you want the {FlowerType} to be picked up?
                contentType: PlainText
            maxAttempts: 2
          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:
            messages:
              - content: Pick up the {FlowerType} at what time on {PickupDate}?
                contentType: PlainText
            maxAttempts: 2
          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
      createVersion: false
      name: OrderFlowers
      description: Intent to order a bouquet of flowers for pick up
      sampleUtterances:
        - I would like to order some flowers
        - I would like to pick up flowers

Import

Using pulumi import, import intents using their name. For example:

$ pulumi import aws:lex/intent:Intent order_flowers_intent OrderFlowers

Constructors

Intent(String name, {IntentArgs? args, CustomResourceOptions? options})
Creates a new Intent. name The Pulumi resource name. args Arguments used to configure this Intent. The set of arguments for Intent. options Resource options controlling this resource's behavior.
Intent.reference(String urn)
Creates a typed reference to an existing Intent resource.

Properties

arn ↔ Output<String>
The ARN of the Lex intent.
latefinal
checksum ↔ Output<String>
Checksum identifying the version of the intent that was created. The checksum is not included as an argument because the resource will add it automatically when updating the intent.
latefinal
childResources → Set<Resource>
finalinherited
completionSources ↔ Map<String, IOutputCompletionSource>
latefinalinherited
conclusionStatement ↔ Output<IntentConclusionStatement?>
The statement that you want Amazon Lex to convey to the user after the intent is successfully fulfilled by the Lambda function. This element is relevant only if you provide a Lambda function in the fulfillmentActivity. If you return the intent to the client application, you can't specify this element. The followUpPrompt and conclusionStatement are mutually exclusive. You can specify only one. Attributes are documented under statement.
latefinal
confirmationPrompt ↔ Output<IntentConfirmationPrompt?>
Prompts the user to confirm the intent. This question should have a yes or no answer. You you must provide both the rejectionStatement and confirmationPrompt, or neither. Attributes are documented under prompt.
latefinal
createdDate ↔ Output<String>
The date when the intent version was created.
latefinal
createVersion ↔ Output<bool?>
Determines if a new slot type version is created when the initial resource is created and on each update. Defaults to false.
latefinal
description ↔ Output<String?>
A description of the intent. Must be less than or equal to 200 characters in length.
latefinal
dialogCodeHook ↔ Output<IntentDialogCodeHook?>
Specifies a Lambda function to invoke for each user input. You can invoke this Lambda function to personalize user interaction. Attributes are documented under code_hook.
latefinal
followUpPrompt ↔ Output<IntentFollowUpPrompt?>
Amazon Lex uses this prompt to solicit additional activity after fulfilling an intent. For example, after the OrderPizza intent is fulfilled, you might prompt the user to order a drink. The followUpPrompt field and the conclusionStatement field are mutually exclusive. You can specify only one. Attributes are documented under follow_up_prompt.
latefinal
fulfillmentActivity ↔ Output<IntentFulfillmentActivity>
Describes how the intent is fulfilled. For example, after a user provides all of the information for a pizza order, fulfillmentActivity defines how the bot places an order with a local pizza store. Attributes are documented under fulfillment_activity.
latefinal
hashCode → int
The hash code for this object.
no setterinherited
id ↔ Output<String>
getter/setter pairinherited
isCustom → bool
Returns whether this resource is provider-managed.
no setterinherited
isProtected → bool
Returns whether this resource is protected from deletion.
no setterinherited
isRemote → bool
Whether this resource is registered as remote.
no setterinherited
isResourceReference → bool
Whether this instance represents a resource value returned over RPC.
finalinherited
lastUpdatedDate ↔ Output<String>
The date when the $LATEST version of this intent was updated.
latefinal
name ↔ Output<String>
The name of the intent, not case sensitive. Must be less than or equal to 100 characters in length.
latefinal
parentIntentSignature ↔ Output<String?>
A unique identifier for the built-in intent to base this intent on. To find the signature for an intent, see Standard Built-in Intents in the Alexa Skills Kit.
latefinal
region ↔ Output<String>
Region where this resource will be managed. Defaults to the Region set in the provider configuration.
latefinal
rejectionStatement ↔ Output<IntentRejectionStatement?>
When the user answers "no" to the question defined in confirmationPrompt, Amazon Lex responds with this statement to acknowledge that the intent was canceled. You must provide both the rejectionStatement and the confirmationPrompt, or neither. Attributes are documented under statement.
latefinal
resourceTransforms → List<ResourceTransform>
Inherited/explicit async transforms.
no setterinherited
runtimeType → Type
A representation of the runtime type of the object.
no setterinherited
sampleUtterances ↔ Output<List<String>?>
An array of utterances (strings) that a user might say to signal the intent. For example, "I want {PizzaSize} pizza", "Order {Quantity} {PizzaSize} pizzas". In each utterance, a slot name is enclosed in curly braces. Must have between 1 and 10 items in the list, and each item must be less than or equal to 200 characters in length.
latefinal
slots ↔ Output<List<IntentSlot>?>
An list of intent slots. At runtime, Amazon Lex elicits required slot values from the user using prompts defined in the slots. Attributes are documented under slot.
latefinal
transformations → List<ResourceTransformation>
Inherited/explicit legacy transformations.
no setterinherited
urn ↔ Output<String>
latefinalinherited
version ↔ Output<String>
The version of the bot.
latefinal

Methods

failId(Object error) → void
Completes this resource ID with an error when registration fails.
inherited
failOutputs(Object error) → void
Completes all output properties with error.
inherited
failUrn(Object error) → void
Completes this resource URN with an error when registration fails.
inherited
getProvider(String moduleMember) → ProviderResource?
Returns provider for moduleMember's package, if configured.
inherited
getResourceName() → String
Returns this resource's logical name.
inherited
getResourceType() → String
Returns this resource's Pulumi type token.
inherited
noSuchMethod(Invocation invocation) → dynamic
Invoked when a nonexistent method or property is accessed.
inherited
registerOutput<T>(String propertyName, {Object? decoder(Object?)?, bool isSecret = false}) → Output<T>
Registers a dynamic output property for this resource.
inherited
resolveId(String? value, {required bool isKnown}) → void
Resolves the provider-assigned ID for this resource.
inherited
resolveOutputs(Struct outputs) → void
Resolves all output properties from a monitor response payload.
inherited
resolveUrn(String value) → void
Resolves this resource's URN once assigned by the engine.
inherited
serializeProperties(Map<String, dynamic> properties) → Future<Struct>
Serializes resource properties for RPC transmission.
inherited
toString() → String
A string representation of this object.
inherited

Operators

operator ==(Object other) → bool
The equality operator.
inherited

Static Methods

get(String name, Input<String> id, {IntentState? state, CustomResourceOptions? options}) → Intent
Gets an existing Intent resource's state with the given name and id.