blib/lib/Paws/LexModels.pm untested

filter: Statementstmt 0.0% 0 / 330 Branchbran 0.0% 0 / 40 Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 55 Podpod 0.0% 0 / 54 totaltotal 0.0% 0 / 479 CC 21 SCAR 17.9
CC
21
Cov
0%
GetAllBotAliases
12.0
GetAllBotChannelAssociations
12.0
GetAllBots
12.0
CRAP 6.0
1 package Paws::LexModels;
2 use Moose;
3 sub service { 'models.lex' }
4 sub signing_name { 'lex' }
5 sub version { '2017-04-19' }
6 sub flattened_arrays { 0 }
7 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8 has retry => (is => 'ro', isa => 'HashRef', default => sub {
9 { base => 'rand', type => 'exponential', growth_factor => 2 }
10 });
11 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12 ] });
13  
14 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::RestJsonCaller';
15  
16
17 sub CreateBotVersion {
18 my $self = shift;
19 my $call_object = $self->new_with_coercions('Paws::LexModels::CreateBotVersion', @_);
20 return $self->caller->do_call($self, $call_object);
21 }
22 sub CreateIntentVersion {
23 my $self = shift;
24 my $call_object = $self->new_with_coercions('Paws::LexModels::CreateIntentVersion', @_);
25 return $self->caller->do_call($self, $call_object);
26 }
27 sub CreateSlotTypeVersion {
28 my $self = shift;
29 my $call_object = $self->new_with_coercions('Paws::LexModels::CreateSlotTypeVersion', @_);
30 return $self->caller->do_call($self, $call_object);
31 }
32 sub DeleteBot {
33 my $self = shift;
34 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteBot', @_);
35 return $self->caller->do_call($self, $call_object);
36 }
37 sub DeleteBotAlias {
38 my $self = shift;
39 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteBotAlias', @_);
40 return $self->caller->do_call($self, $call_object);
41 }
42 sub DeleteBotChannelAssociation {
43 my $self = shift;
44 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteBotChannelAssociation', @_);
45 return $self->caller->do_call($self, $call_object);
46 }
47 sub DeleteBotVersion {
48 my $self = shift;
49 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteBotVersion', @_);
50 return $self->caller->do_call($self, $call_object);
51 }
52 sub DeleteIntent {
53 my $self = shift;
54 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteIntent', @_);
55 return $self->caller->do_call($self, $call_object);
56 }
57 sub DeleteIntentVersion {
58 my $self = shift;
59 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteIntentVersion', @_);
60 return $self->caller->do_call($self, $call_object);
61 }
62 sub DeleteSlotType {
63 my $self = shift;
64 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteSlotType', @_);
65 return $self->caller->do_call($self, $call_object);
66 }
67 sub DeleteSlotTypeVersion {
68 my $self = shift;
69 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteSlotTypeVersion', @_);
70 return $self->caller->do_call($self, $call_object);
71 }
72 sub DeleteUtterances {
73 my $self = shift;
74 my $call_object = $self->new_with_coercions('Paws::LexModels::DeleteUtterances', @_);
75 return $self->caller->do_call($self, $call_object);
76 }
77 sub GetBot {
78 my $self = shift;
79 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBot', @_);
80 return $self->caller->do_call($self, $call_object);
81 }
82 sub GetBotAlias {
83 my $self = shift;
84 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBotAlias', @_);
85 return $self->caller->do_call($self, $call_object);
86 }
87 sub GetBotAliases {
88 my $self = shift;
89 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBotAliases', @_);
90 return $self->caller->do_call($self, $call_object);
91 }
92 sub GetBotChannelAssociation {
93 my $self = shift;
94 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBotChannelAssociation', @_);
95 return $self->caller->do_call($self, $call_object);
96 }
97 sub GetBotChannelAssociations {
98 my $self = shift;
99 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBotChannelAssociations', @_);
100 return $self->caller->do_call($self, $call_object);
101 }
102 sub GetBots {
103 my $self = shift;
104 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBots', @_);
105 return $self->caller->do_call($self, $call_object);
106 }
107 sub GetBotVersions {
108 my $self = shift;
109 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBotVersions', @_);
110 return $self->caller->do_call($self, $call_object);
111 }
112 sub GetBuiltinIntent {
113 my $self = shift;
114 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBuiltinIntent', @_);
115 return $self->caller->do_call($self, $call_object);
116 }
117 sub GetBuiltinIntents {
118 my $self = shift;
119 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBuiltinIntents', @_);
120 return $self->caller->do_call($self, $call_object);
121 }
122 sub GetBuiltinSlotTypes {
123 my $self = shift;
124 my $call_object = $self->new_with_coercions('Paws::LexModels::GetBuiltinSlotTypes', @_);
125 return $self->caller->do_call($self, $call_object);
126 }
127 sub GetExport {
128 my $self = shift;
129 my $call_object = $self->new_with_coercions('Paws::LexModels::GetExport', @_);
130 return $self->caller->do_call($self, $call_object);
131 }
132 sub GetImport {
133 my $self = shift;
134 my $call_object = $self->new_with_coercions('Paws::LexModels::GetImport', @_);
135 return $self->caller->do_call($self, $call_object);
136 }
137 sub GetIntent {
138 my $self = shift;
139 my $call_object = $self->new_with_coercions('Paws::LexModels::GetIntent', @_);
140 return $self->caller->do_call($self, $call_object);
141 }
142 sub GetIntents {
143 my $self = shift;
144 my $call_object = $self->new_with_coercions('Paws::LexModels::GetIntents', @_);
145 return $self->caller->do_call($self, $call_object);
146 }
147 sub GetIntentVersions {
148 my $self = shift;
149 my $call_object = $self->new_with_coercions('Paws::LexModels::GetIntentVersions', @_);
150 return $self->caller->do_call($self, $call_object);
151 }
152 sub GetSlotType {
153 my $self = shift;
154 my $call_object = $self->new_with_coercions('Paws::LexModels::GetSlotType', @_);
155 return $self->caller->do_call($self, $call_object);
156 }
157 sub GetSlotTypes {
158 my $self = shift;
159 my $call_object = $self->new_with_coercions('Paws::LexModels::GetSlotTypes', @_);
160 return $self->caller->do_call($self, $call_object);
161 }
162 sub GetSlotTypeVersions {
163 my $self = shift;
164 my $call_object = $self->new_with_coercions('Paws::LexModels::GetSlotTypeVersions', @_);
165 return $self->caller->do_call($self, $call_object);
166 }
167 sub GetUtterancesView {
168 my $self = shift;
169 my $call_object = $self->new_with_coercions('Paws::LexModels::GetUtterancesView', @_);
170 return $self->caller->do_call($self, $call_object);
171 }
172 sub ListTagsForResource {
173 my $self = shift;
174 my $call_object = $self->new_with_coercions('Paws::LexModels::ListTagsForResource', @_);
175 return $self->caller->do_call($self, $call_object);
176 }
177 sub PutBot {
178 my $self = shift;
179 my $call_object = $self->new_with_coercions('Paws::LexModels::PutBot', @_);
180 return $self->caller->do_call($self, $call_object);
181 }
182 sub PutBotAlias {
183 my $self = shift;
184 my $call_object = $self->new_with_coercions('Paws::LexModels::PutBotAlias', @_);
185 return $self->caller->do_call($self, $call_object);
186 }
187 sub PutIntent {
188 my $self = shift;
189 my $call_object = $self->new_with_coercions('Paws::LexModels::PutIntent', @_);
190 return $self->caller->do_call($self, $call_object);
191 }
192 sub PutSlotType {
193 my $self = shift;
194 my $call_object = $self->new_with_coercions('Paws::LexModels::PutSlotType', @_);
195 return $self->caller->do_call($self, $call_object);
196 }
197 sub StartImport {
198 my $self = shift;
199 my $call_object = $self->new_with_coercions('Paws::LexModels::StartImport', @_);
200 return $self->caller->do_call($self, $call_object);
201 }
202 sub TagResource {
203 my $self = shift;
204 my $call_object = $self->new_with_coercions('Paws::LexModels::TagResource', @_);
205 return $self->caller->do_call($self, $call_object);
206 }
207 sub UntagResource {
208 my $self = shift;
209 my $call_object = $self->new_with_coercions('Paws::LexModels::UntagResource', @_);
210 return $self->caller->do_call($self, $call_object);
211 }
212
213 sub GetAllBotAliases {
214 my $self = shift;
215  
216 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
217 my $result = $self->GetBotAliases(@_);
218 my $next_result = $result;
219  
220 if (not defined $callback) {
221 while ($next_result->nextToken) {
222 $next_result = $self->GetBotAliases(@_, nextToken => $next_result->nextToken);
223 push @{ $result->BotAliases }, @{ $next_result->BotAliases };
224 }
225 return $result;
226 } else {
227 while ($result->nextToken) {
228 $callback->($_ => 'BotAliases') foreach (@{ $result->BotAliases });
229 $result = $self->GetBotAliases(@_, nextToken => $result->nextToken);
230 }
231 $callback->($_ => 'BotAliases') foreach (@{ $result->BotAliases });
232 }
233  
234 return undef
235 }
236 sub GetAllBotChannelAssociations {
237 my $self = shift;
238  
239 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
240 my $result = $self->GetBotChannelAssociations(@_);
241 my $next_result = $result;
242  
243 if (not defined $callback) {
244 while ($next_result->nextToken) {
245 $next_result = $self->GetBotChannelAssociations(@_, nextToken => $next_result->nextToken);
246 push @{ $result->botChannelAssociations }, @{ $next_result->botChannelAssociations };
247 }
248 return $result;
249 } else {
250 while ($result->nextToken) {
251 $callback->($_ => 'botChannelAssociations') foreach (@{ $result->botChannelAssociations });
252 $result = $self->GetBotChannelAssociations(@_, nextToken => $result->nextToken);
253 }
254 $callback->($_ => 'botChannelAssociations') foreach (@{ $result->botChannelAssociations });
255 }
256  
257 return undef
258 }
259 sub GetAllBots {
260 my $self = shift;
261  
262 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
263 my $result = $self->GetBots(@_);
264 my $next_result = $result;
265  
266 if (not defined $callback) {
267 while ($next_result->nextToken) {
268 $next_result = $self->GetBots(@_, nextToken => $next_result->nextToken);
269 push @{ $result->bots }, @{ $next_result->bots };
270 }
271 return $result;
272 } else {
273 while ($result->nextToken) {
274 $callback->($_ => 'bots') foreach (@{ $result->bots });
275 $result = $self->GetBots(@_, nextToken => $result->nextToken);
276 }
277 $callback->($_ => 'bots') foreach (@{ $result->bots });
278 }
279  
280 return undef
281 }
282 sub GetAllBotVersions {
283 my $self = shift;
284  
285 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
286 my $result = $self->GetBotVersions(@_);
287 my $next_result = $result;
288  
289 if (not defined $callback) {
290 while ($next_result->nextToken) {
291 $next_result = $self->GetBotVersions(@_, nextToken => $next_result->nextToken);
292 push @{ $result->bots }, @{ $next_result->bots };
293 }
294 return $result;
295 } else {
296 while ($result->nextToken) {
297 $callback->($_ => 'bots') foreach (@{ $result->bots });
298 $result = $self->GetBotVersions(@_, nextToken => $result->nextToken);
299 }
300 $callback->($_ => 'bots') foreach (@{ $result->bots });
301 }
302  
303 return undef
304 }
305 sub GetAllBuiltinIntents {
306 my $self = shift;
307  
308 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
309 my $result = $self->GetBuiltinIntents(@_);
310 my $next_result = $result;
311  
312 if (not defined $callback) {
313 while ($next_result->nextToken) {
314 $next_result = $self->GetBuiltinIntents(@_, nextToken => $next_result->nextToken);
315 push @{ $result->intents }, @{ $next_result->intents };
316 }
317 return $result;
318 } else {
319 while ($result->nextToken) {
320 $callback->($_ => 'intents') foreach (@{ $result->intents });
321 $result = $self->GetBuiltinIntents(@_, nextToken => $result->nextToken);
322 }
323 $callback->($_ => 'intents') foreach (@{ $result->intents });
324 }
325  
326 return undef
327 }
328 sub GetAllBuiltinSlotTypes {
329 my $self = shift;
330  
331 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
332 my $result = $self->GetBuiltinSlotTypes(@_);
333 my $next_result = $result;
334  
335 if (not defined $callback) {
336 while ($next_result->nextToken) {
337 $next_result = $self->GetBuiltinSlotTypes(@_, nextToken => $next_result->nextToken);
338 push @{ $result->slotTypes }, @{ $next_result->slotTypes };
339 }
340 return $result;
341 } else {
342 while ($result->nextToken) {
343 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
344 $result = $self->GetBuiltinSlotTypes(@_, nextToken => $result->nextToken);
345 }
346 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
347 }
348  
349 return undef
350 }
351 sub GetAllIntents {
352 my $self = shift;
353  
354 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
355 my $result = $self->GetIntents(@_);
356 my $next_result = $result;
357  
358 if (not defined $callback) {
359 while ($next_result->nextToken) {
360 $next_result = $self->GetIntents(@_, nextToken => $next_result->nextToken);
361 push @{ $result->intents }, @{ $next_result->intents };
362 }
363 return $result;
364 } else {
365 while ($result->nextToken) {
366 $callback->($_ => 'intents') foreach (@{ $result->intents });
367 $result = $self->GetIntents(@_, nextToken => $result->nextToken);
368 }
369 $callback->($_ => 'intents') foreach (@{ $result->intents });
370 }
371  
372 return undef
373 }
374 sub GetAllIntentVersions {
375 my $self = shift;
376  
377 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
378 my $result = $self->GetIntentVersions(@_);
379 my $next_result = $result;
380  
381 if (not defined $callback) {
382 while ($next_result->nextToken) {
383 $next_result = $self->GetIntentVersions(@_, nextToken => $next_result->nextToken);
384 push @{ $result->intents }, @{ $next_result->intents };
385 }
386 return $result;
387 } else {
388 while ($result->nextToken) {
389 $callback->($_ => 'intents') foreach (@{ $result->intents });
390 $result = $self->GetIntentVersions(@_, nextToken => $result->nextToken);
391 }
392 $callback->($_ => 'intents') foreach (@{ $result->intents });
393 }
394  
395 return undef
396 }
397 sub GetAllSlotTypes {
398 my $self = shift;
399  
400 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
401 my $result = $self->GetSlotTypes(@_);
402 my $next_result = $result;
403  
404 if (not defined $callback) {
405 while ($next_result->nextToken) {
406 $next_result = $self->GetSlotTypes(@_, nextToken => $next_result->nextToken);
407 push @{ $result->slotTypes }, @{ $next_result->slotTypes };
408 }
409 return $result;
410 } else {
411 while ($result->nextToken) {
412 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
413 $result = $self->GetSlotTypes(@_, nextToken => $result->nextToken);
414 }
415 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
416 }
417  
418 return undef
419 }
420 sub GetAllSlotTypeVersions {
421 my $self = shift;
422  
423 my $callback = shift @_ if (ref($_[0]) eq 'CODE');
424 my $result = $self->GetSlotTypeVersions(@_);
425 my $next_result = $result;
426  
427 if (not defined $callback) {
428 while ($next_result->nextToken) {
429 $next_result = $self->GetSlotTypeVersions(@_, nextToken => $next_result->nextToken);
430 push @{ $result->slotTypes }, @{ $next_result->slotTypes };
431 }
432 return $result;
433 } else {
434 while ($result->nextToken) {
435 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
436 $result = $self->GetSlotTypeVersions(@_, nextToken => $result->nextToken);
437 }
438 $callback->($_ => 'slotTypes') foreach (@{ $result->slotTypes });
439 }
440  
441 return undef
442 }
443  
444  
445 sub operations { qw/CreateBotVersion CreateIntentVersion CreateSlotTypeVersion DeleteBot DeleteBotAlias DeleteBotChannelAssociation DeleteBotVersion DeleteIntent DeleteIntentVersion DeleteSlotType DeleteSlotTypeVersion DeleteUtterances GetBot GetBotAlias GetBotAliases GetBotChannelAssociation GetBotChannelAssociations GetBots GetBotVersions GetBuiltinIntent GetBuiltinIntents GetBuiltinSlotTypes GetExport GetImport GetIntent GetIntents GetIntentVersions GetSlotType GetSlotTypes GetSlotTypeVersions GetUtterancesView ListTagsForResource PutBot PutBotAlias PutIntent PutSlotType StartImport TagResource UntagResource / }
446  
447 1;
448  
449 ### main pod documentation begin ###
450  
451 =head1 NAME
452  
453 Paws::LexModels - Perl Interface to AWS Amazon Lex Model Building Service
454  
455 =head1 SYNOPSIS
456  
457 use Paws;
458  
459 my $obj = Paws->service('LexModels');
460 my $res = $obj->Method(
461 Arg1 => $val1,
462 Arg2 => [ 'V1', 'V2' ],
463 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
464 # of the arguments type
465 Arg3 => { Att1 => 'Val1' },
466 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
467 # the constructor of the arguments type
468 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
469 );
470  
471 =head1 DESCRIPTION
472  
473 Amazon Lex Build-Time Actions
474  
475 Amazon Lex is an AWS service for building conversational voice and text
476 interfaces. Use these actions to create, update, and delete
477 conversational bots for new and existing client applications.
478  
479 For the AWS API documentation, see L<https://docs.aws.amazon.com/lex/>
480  
481  
482 =head1 METHODS
483  
484 =head2 CreateBotVersion
485  
486 =over
487  
488 =item Name => Str
489  
490 =item [Checksum => Str]
491  
492  
493 =back
494  
495 Each argument is described in detail in: L<Paws::LexModels::CreateBotVersion>
496  
497 Returns: a L<Paws::LexModels::CreateBotVersionResponse> instance
498  
499 Creates a new version of the bot based on the C<$LATEST> version. If
500 the C<$LATEST> version of this resource hasn't changed since you
501 created the last version, Amazon Lex doesn't create a new version. It
502 returns the last created version.
503  
504 You can update only the C<$LATEST> version of the bot. You can't update
505 the numbered versions that you create with the C<CreateBotVersion>
506 operation.
507  
508 When you create the first version of a bot, Amazon Lex sets the version
509 to 1. Subsequent versions increment by 1. For more information, see
510 versioning-intro.
511  
512 This operation requires permission for the C<lex:CreateBotVersion>
513 action.
514  
515  
516 =head2 CreateIntentVersion
517  
518 =over
519  
520 =item Name => Str
521  
522 =item [Checksum => Str]
523  
524  
525 =back
526  
527 Each argument is described in detail in: L<Paws::LexModels::CreateIntentVersion>
528  
529 Returns: a L<Paws::LexModels::CreateIntentVersionResponse> instance
530  
531 Creates a new version of an intent based on the C<$LATEST> version of
532 the intent. If the C<$LATEST> version of this intent hasn't changed
533 since you last updated it, Amazon Lex doesn't create a new version. It
534 returns the last version you created.
535  
536 You can update only the C<$LATEST> version of the intent. You can't
537 update the numbered versions that you create with the
538 C<CreateIntentVersion> operation.
539  
540 When you create a version of an intent, Amazon Lex sets the version to
541 1. Subsequent versions increment by 1. For more information, see
542 versioning-intro.
543  
544 This operation requires permissions to perform the
545 C<lex:CreateIntentVersion> action.
546  
547  
548 =head2 CreateSlotTypeVersion
549  
550 =over
551  
552 =item Name => Str
553  
554 =item [Checksum => Str]
555  
556  
557 =back
558  
559 Each argument is described in detail in: L<Paws::LexModels::CreateSlotTypeVersion>
560  
561 Returns: a L<Paws::LexModels::CreateSlotTypeVersionResponse> instance
562  
563 Creates a new version of a slot type based on the C<$LATEST> version of
564 the specified slot type. If the C<$LATEST> version of this resource has
565 not changed since the last version that you created, Amazon Lex doesn't
566 create a new version. It returns the last version that you created.
567  
568 You can update only the C<$LATEST> version of a slot type. You can't
569 update the numbered versions that you create with the
570 C<CreateSlotTypeVersion> operation.
571  
572 When you create a version of a slot type, Amazon Lex sets the version
573 to 1. Subsequent versions increment by 1. For more information, see
574 versioning-intro.
575  
576 This operation requires permissions for the
577 C<lex:CreateSlotTypeVersion> action.
578  
579  
580 =head2 DeleteBot
581  
582 =over
583  
584 =item Name => Str
585  
586  
587 =back
588  
589 Each argument is described in detail in: L<Paws::LexModels::DeleteBot>
590  
591 Returns: nothing
592  
593 Deletes all versions of the bot, including the C<$LATEST> version. To
594 delete a specific version of the bot, use the DeleteBotVersion
595 operation. The C<DeleteBot> operation doesn't immediately remove the
596 bot schema. Instead, it is marked for deletion and removed later.
597  
598 Amazon Lex stores utterances indefinitely for improving the ability of
599 your bot to respond to user inputs. These utterances are not removed
600 when the bot is deleted. To remove the utterances, use the
601 DeleteUtterances operation.
602  
603 If a bot has an alias, you can't delete it. Instead, the C<DeleteBot>
604 operation returns a C<ResourceInUseException> exception that includes a
605 reference to the alias that refers to the bot. To remove the reference
606 to the bot, delete the alias. If you get the same exception again,
607 delete the referring alias until the C<DeleteBot> operation is
608 successful.
609  
610 This operation requires permissions for the C<lex:DeleteBot> action.
611  
612  
613 =head2 DeleteBotAlias
614  
615 =over
616  
617 =item BotName => Str
618  
619 =item Name => Str
620  
621  
622 =back
623  
624 Each argument is described in detail in: L<Paws::LexModels::DeleteBotAlias>
625  
626 Returns: nothing
627  
628 Deletes an alias for the specified bot.
629  
630 You can't delete an alias that is used in the association between a bot
631 and a messaging channel. If an alias is used in a channel association,
632 the C<DeleteBot> operation returns a C<ResourceInUseException>
633 exception that includes a reference to the channel association that
634 refers to the bot. You can remove the reference to the alias by
635 deleting the channel association. If you get the same exception again,
636 delete the referring association until the C<DeleteBotAlias> operation
637 is successful.
638  
639  
640 =head2 DeleteBotChannelAssociation
641  
642 =over
643  
644 =item BotAlias => Str
645  
646 =item BotName => Str
647  
648 =item Name => Str
649  
650  
651 =back
652  
653 Each argument is described in detail in: L<Paws::LexModels::DeleteBotChannelAssociation>
654  
655 Returns: nothing
656  
657 Deletes the association between an Amazon Lex bot and a messaging
658 platform.
659  
660 This operation requires permission for the
661 C<lex:DeleteBotChannelAssociation> action.
662  
663  
664 =head2 DeleteBotVersion
665  
666 =over
667  
668 =item Name => Str
669  
670 =item Version => Str
671  
672  
673 =back
674  
675 Each argument is described in detail in: L<Paws::LexModels::DeleteBotVersion>
676  
677 Returns: nothing
678  
679 Deletes a specific version of a bot. To delete all versions of a bot,
680 use the DeleteBot operation.
681  
682 This operation requires permissions for the C<lex:DeleteBotVersion>
683 action.
684  
685  
686 =head2 DeleteIntent
687  
688 =over
689  
690 =item Name => Str
691  
692  
693 =back
694  
695 Each argument is described in detail in: L<Paws::LexModels::DeleteIntent>
696  
697 Returns: nothing
698  
699 Deletes all versions of the intent, including the C<$LATEST> version.
700 To delete a specific version of the intent, use the DeleteIntentVersion
701 operation.
702  
703 You can delete a version of an intent only if it is not referenced. To
704 delete an intent that is referred to in one or more bots (see
705 how-it-works), you must remove those references first.
706  
707 If you get the C<ResourceInUseException> exception, it provides an
708 example reference that shows where the intent is referenced. To remove
709 the reference to the intent, either update the bot or delete it. If you
710 get the same exception when you attempt to delete the intent again,
711 repeat until the intent has no references and the call to
712 C<DeleteIntent> is successful.
713  
714 This operation requires permission for the C<lex:DeleteIntent> action.
715  
716  
717 =head2 DeleteIntentVersion
718  
719 =over
720  
721 =item Name => Str
722  
723 =item Version => Str
724  
725  
726 =back
727  
728 Each argument is described in detail in: L<Paws::LexModels::DeleteIntentVersion>
729  
730 Returns: nothing
731  
732 Deletes a specific version of an intent. To delete all versions of a
733 intent, use the DeleteIntent operation.
734  
735 This operation requires permissions for the C<lex:DeleteIntentVersion>
736 action.
737  
738  
739 =head2 DeleteSlotType
740  
741 =over
742  
743 =item Name => Str
744  
745  
746 =back
747  
748 Each argument is described in detail in: L<Paws::LexModels::DeleteSlotType>
749  
750 Returns: nothing
751  
752 Deletes all versions of the slot type, including the C<$LATEST>
753 version. To delete a specific version of the slot type, use the
754 DeleteSlotTypeVersion operation.
755  
756 You can delete a version of a slot type only if it is not referenced.
757 To delete a slot type that is referred to in one or more intents, you
758 must remove those references first.
759  
760 If you get the C<ResourceInUseException> exception, the exception
761 provides an example reference that shows the intent where the slot type
762 is referenced. To remove the reference to the slot type, either update
763 the intent or delete it. If you get the same exception when you attempt
764 to delete the slot type again, repeat until the slot type has no
765 references and the C<DeleteSlotType> call is successful.
766  
767 This operation requires permission for the C<lex:DeleteSlotType>
768 action.
769  
770  
771 =head2 DeleteSlotTypeVersion
772  
773 =over
774  
775 =item Name => Str
776  
777 =item Version => Str
778  
779  
780 =back
781  
782 Each argument is described in detail in: L<Paws::LexModels::DeleteSlotTypeVersion>
783  
784 Returns: nothing
785  
786 Deletes a specific version of a slot type. To delete all versions of a
787 slot type, use the DeleteSlotType operation.
788  
789 This operation requires permissions for the
790 C<lex:DeleteSlotTypeVersion> action.
791  
792  
793 =head2 DeleteUtterances
794  
795 =over
796  
797 =item BotName => Str
798  
799 =item UserId => Str
800  
801  
802 =back
803  
804 Each argument is described in detail in: L<Paws::LexModels::DeleteUtterances>
805  
806 Returns: nothing
807  
808 Deletes stored utterances.
809  
810 Amazon Lex stores the utterances that users send to your bot.
811 Utterances are stored for 15 days for use with the GetUtterancesView
812 operation, and then stored indefinitely for use in improving the
813 ability of your bot to respond to user input.
814  
815 Use the C<DeleteUtterances> operation to manually delete stored
816 utterances for a specific user. When you use the C<DeleteUtterances>
817 operation, utterances stored for improving your bot's ability to
818 respond to user input are deleted immediately. Utterances stored for
819 use with the C<GetUtterancesView> operation are deleted after 15 days.
820  
821 This operation requires permissions for the C<lex:DeleteUtterances>
822 action.
823  
824  
825 =head2 GetBot
826  
827 =over
828  
829 =item Name => Str
830  
831 =item VersionOrAlias => Str
832  
833  
834 =back
835  
836 Each argument is described in detail in: L<Paws::LexModels::GetBot>
837  
838 Returns: a L<Paws::LexModels::GetBotResponse> instance
839  
840 Returns metadata information for a specific bot. You must provide the
841 bot name and the bot version or alias.
842  
843 This operation requires permissions for the C<lex:GetBot> action.
844  
845  
846 =head2 GetBotAlias
847  
848 =over
849  
850 =item BotName => Str
851  
852 =item Name => Str
853  
854  
855 =back
856  
857 Each argument is described in detail in: L<Paws::LexModels::GetBotAlias>
858  
859 Returns: a L<Paws::LexModels::GetBotAliasResponse> instance
860  
861 Returns information about an Amazon Lex bot alias. For more information
862 about aliases, see versioning-aliases.
863  
864 This operation requires permissions for the C<lex:GetBotAlias> action.
865  
866  
867 =head2 GetBotAliases
868  
869 =over
870  
871 =item BotName => Str
872  
873 =item [MaxResults => Int]
874  
875 =item [NameContains => Str]
876  
877 =item [NextToken => Str]
878  
879  
880 =back
881  
882 Each argument is described in detail in: L<Paws::LexModels::GetBotAliases>
883  
884 Returns: a L<Paws::LexModels::GetBotAliasesResponse> instance
885  
886 Returns a list of aliases for a specified Amazon Lex bot.
887  
888 This operation requires permissions for the C<lex:GetBotAliases>
889 action.
890  
891  
892 =head2 GetBotChannelAssociation
893  
894 =over
895  
896 =item BotAlias => Str
897  
898 =item BotName => Str
899  
900 =item Name => Str
901  
902  
903 =back
904  
905 Each argument is described in detail in: L<Paws::LexModels::GetBotChannelAssociation>
906  
907 Returns: a L<Paws::LexModels::GetBotChannelAssociationResponse> instance
908  
909 Returns information about the association between an Amazon Lex bot and
910 a messaging platform.
911  
912 This operation requires permissions for the
913 C<lex:GetBotChannelAssociation> action.
914  
915  
916 =head2 GetBotChannelAssociations
917  
918 =over
919  
920 =item BotAlias => Str
921  
922 =item BotName => Str
923  
924 =item [MaxResults => Int]
925  
926 =item [NameContains => Str]
927  
928 =item [NextToken => Str]
929  
930  
931 =back
932  
933 Each argument is described in detail in: L<Paws::LexModels::GetBotChannelAssociations>
934  
935 Returns: a L<Paws::LexModels::GetBotChannelAssociationsResponse> instance
936  
937 Returns a list of all of the channels associated with the specified
938 bot.
939  
940 The C<GetBotChannelAssociations> operation requires permissions for the
941 C<lex:GetBotChannelAssociations> action.
942  
943  
944 =head2 GetBots
945  
946 =over
947  
948 =item [MaxResults => Int]
949  
950 =item [NameContains => Str]
951  
952 =item [NextToken => Str]
953  
954  
955 =back
956  
957 Each argument is described in detail in: L<Paws::LexModels::GetBots>
958  
959 Returns: a L<Paws::LexModels::GetBotsResponse> instance
960  
961 Returns bot information as follows:
962  
963 =over
964  
965 =item *
966  
967 If you provide the C<nameContains> field, the response includes
968 information for the C<$LATEST> version of all bots whose name contains
969 the specified string.
970  
971 =item *
972  
973 If you don't specify the C<nameContains> field, the operation returns
974 information about the C<$LATEST> version of all of your bots.
975  
976 =back
977  
978 This operation requires permission for the C<lex:GetBots> action.
979  
980  
981 =head2 GetBotVersions
982  
983 =over
984  
985 =item Name => Str
986  
987 =item [MaxResults => Int]
988  
989 =item [NextToken => Str]
990  
991  
992 =back
993  
994 Each argument is described in detail in: L<Paws::LexModels::GetBotVersions>
995  
996 Returns: a L<Paws::LexModels::GetBotVersionsResponse> instance
997  
998 Gets information about all of the versions of a bot.
999  
1000 The C<GetBotVersions> operation returns a C<BotMetadata> object for
1001 each version of a bot. For example, if a bot has three numbered
1002 versions, the C<GetBotVersions> operation returns four C<BotMetadata>
1003 objects in the response, one for each numbered version and one for the
1004 C<$LATEST> version.
1005  
1006 The C<GetBotVersions> operation always returns at least one version,
1007 the C<$LATEST> version.
1008  
1009 This operation requires permissions for the C<lex:GetBotVersions>
1010 action.
1011  
1012  
1013 =head2 GetBuiltinIntent
1014  
1015 =over
1016  
1017 =item Signature => Str
1018  
1019  
1020 =back
1021  
1022 Each argument is described in detail in: L<Paws::LexModels::GetBuiltinIntent>
1023  
1024 Returns: a L<Paws::LexModels::GetBuiltinIntentResponse> instance
1025  
1026 Returns information about a built-in intent.
1027  
1028 This operation requires permission for the C<lex:GetBuiltinIntent>
1029 action.
1030  
1031  
1032 =head2 GetBuiltinIntents
1033  
1034 =over
1035  
1036 =item [Locale => Str]
1037  
1038 =item [MaxResults => Int]
1039  
1040 =item [NextToken => Str]
1041  
1042 =item [SignatureContains => Str]
1043  
1044  
1045 =back
1046  
1047 Each argument is described in detail in: L<Paws::LexModels::GetBuiltinIntents>
1048  
1049 Returns: a L<Paws::LexModels::GetBuiltinIntentsResponse> instance
1050  
1051 Gets a list of built-in intents that meet the specified criteria.
1052  
1053 This operation requires permission for the C<lex:GetBuiltinIntents>
1054 action.
1055  
1056  
1057 =head2 GetBuiltinSlotTypes
1058  
1059 =over
1060  
1061 =item [Locale => Str]
1062  
1063 =item [MaxResults => Int]
1064  
1065 =item [NextToken => Str]
1066  
1067 =item [SignatureContains => Str]
1068  
1069  
1070 =back
1071  
1072 Each argument is described in detail in: L<Paws::LexModels::GetBuiltinSlotTypes>
1073  
1074 Returns: a L<Paws::LexModels::GetBuiltinSlotTypesResponse> instance
1075  
1076 Gets a list of built-in slot types that meet the specified criteria.
1077  
1078 For a list of built-in slot types, see Slot Type Reference
1079 (https://developer.amazon.com/public/solutions/alexa/alexa-skills-kit/docs/built-in-intent-ref/slot-type-reference)
1080 in the I<Alexa Skills Kit>.
1081  
1082 This operation requires permission for the C<lex:GetBuiltInSlotTypes>
1083 action.
1084  
1085  
1086 =head2 GetExport
1087  
1088 =over
1089  
1090 =item ExportType => Str
1091  
1092 =item Name => Str
1093  
1094 =item ResourceType => Str
1095  
1096 =item Version => Str
1097  
1098  
1099 =back
1100  
1101 Each argument is described in detail in: L<Paws::LexModels::GetExport>
1102  
1103 Returns: a L<Paws::LexModels::GetExportResponse> instance
1104  
1105 Exports the contents of a Amazon Lex resource in a specified format.
1106  
1107  
1108 =head2 GetImport
1109  
1110 =over
1111  
1112 =item ImportId => Str
1113  
1114  
1115 =back
1116  
1117 Each argument is described in detail in: L<Paws::LexModels::GetImport>
1118  
1119 Returns: a L<Paws::LexModels::GetImportResponse> instance
1120  
1121 Gets information about an import job started with the C<StartImport>
1122 operation.
1123  
1124  
1125 =head2 GetIntent
1126  
1127 =over
1128  
1129 =item Name => Str
1130  
1131 =item Version => Str
1132  
1133  
1134 =back
1135  
1136 Each argument is described in detail in: L<Paws::LexModels::GetIntent>
1137  
1138 Returns: a L<Paws::LexModels::GetIntentResponse> instance
1139  
1140 Returns information about an intent. In addition to the intent name,
1141 you must specify the intent version.
1142  
1143 This operation requires permissions to perform the C<lex:GetIntent>
1144 action.
1145  
1146  
1147 =head2 GetIntents
1148  
1149 =over
1150  
1151 =item [MaxResults => Int]
1152  
1153 =item [NameContains => Str]
1154  
1155 =item [NextToken => Str]
1156  
1157  
1158 =back
1159  
1160 Each argument is described in detail in: L<Paws::LexModels::GetIntents>
1161  
1162 Returns: a L<Paws::LexModels::GetIntentsResponse> instance
1163  
1164 Returns intent information as follows:
1165  
1166 =over
1167  
1168 =item *
1169  
1170 If you specify the C<nameContains> field, returns the C<$LATEST>
1171 version of all intents that contain the specified string.
1172  
1173 =item *
1174  
1175 If you don't specify the C<nameContains> field, returns information
1176 about the C<$LATEST> version of all intents.
1177  
1178 =back
1179  
1180 The operation requires permission for the C<lex:GetIntents> action.
1181  
1182  
1183 =head2 GetIntentVersions
1184  
1185 =over
1186  
1187 =item Name => Str
1188  
1189 =item [MaxResults => Int]
1190  
1191 =item [NextToken => Str]
1192  
1193  
1194 =back
1195  
1196 Each argument is described in detail in: L<Paws::LexModels::GetIntentVersions>
1197  
1198 Returns: a L<Paws::LexModels::GetIntentVersionsResponse> instance
1199  
1200 Gets information about all of the versions of an intent.
1201  
1202 The C<GetIntentVersions> operation returns an C<IntentMetadata> object
1203 for each version of an intent. For example, if an intent has three
1204 numbered versions, the C<GetIntentVersions> operation returns four
1205 C<IntentMetadata> objects in the response, one for each numbered
1206 version and one for the C<$LATEST> version.
1207  
1208 The C<GetIntentVersions> operation always returns at least one version,
1209 the C<$LATEST> version.
1210  
1211 This operation requires permissions for the C<lex:GetIntentVersions>
1212 action.
1213  
1214  
1215 =head2 GetSlotType
1216  
1217 =over
1218  
1219 =item Name => Str
1220  
1221 =item Version => Str
1222  
1223  
1224 =back
1225  
1226 Each argument is described in detail in: L<Paws::LexModels::GetSlotType>
1227  
1228 Returns: a L<Paws::LexModels::GetSlotTypeResponse> instance
1229  
1230 Returns information about a specific version of a slot type. In
1231 addition to specifying the slot type name, you must specify the slot
1232 type version.
1233  
1234 This operation requires permissions for the C<lex:GetSlotType> action.
1235  
1236  
1237 =head2 GetSlotTypes
1238  
1239 =over
1240  
1241 =item [MaxResults => Int]
1242  
1243 =item [NameContains => Str]
1244  
1245 =item [NextToken => Str]
1246  
1247  
1248 =back
1249  
1250 Each argument is described in detail in: L<Paws::LexModels::GetSlotTypes>
1251  
1252 Returns: a L<Paws::LexModels::GetSlotTypesResponse> instance
1253  
1254 Returns slot type information as follows:
1255  
1256 =over
1257  
1258 =item *
1259  
1260 If you specify the C<nameContains> field, returns the C<$LATEST>
1261 version of all slot types that contain the specified string.
1262  
1263 =item *
1264  
1265 If you don't specify the C<nameContains> field, returns information
1266 about the C<$LATEST> version of all slot types.
1267  
1268 =back
1269  
1270 The operation requires permission for the C<lex:GetSlotTypes> action.
1271  
1272  
1273 =head2 GetSlotTypeVersions
1274  
1275 =over
1276  
1277 =item Name => Str
1278  
1279 =item [MaxResults => Int]
1280  
1281 =item [NextToken => Str]
1282  
1283  
1284 =back
1285  
1286 Each argument is described in detail in: L<Paws::LexModels::GetSlotTypeVersions>
1287  
1288 Returns: a L<Paws::LexModels::GetSlotTypeVersionsResponse> instance
1289  
1290 Gets information about all versions of a slot type.
1291  
1292 The C<GetSlotTypeVersions> operation returns a C<SlotTypeMetadata>
1293 object for each version of a slot type. For example, if a slot type has
1294 three numbered versions, the C<GetSlotTypeVersions> operation returns
1295 four C<SlotTypeMetadata> objects in the response, one for each numbered
1296 version and one for the C<$LATEST> version.
1297  
1298 The C<GetSlotTypeVersions> operation always returns at least one
1299 version, the C<$LATEST> version.
1300  
1301 This operation requires permissions for the C<lex:GetSlotTypeVersions>
1302 action.
1303  
1304  
1305 =head2 GetUtterancesView
1306  
1307 =over
1308  
1309 =item BotName => Str
1310  
1311 =item BotVersions => ArrayRef[Str|Undef]
1312  
1313 =item StatusType => Str
1314  
1315  
1316 =back
1317  
1318 Each argument is described in detail in: L<Paws::LexModels::GetUtterancesView>
1319  
1320 Returns: a L<Paws::LexModels::GetUtterancesViewResponse> instance
1321  
1322 Use the C<GetUtterancesView> operation to get information about the
1323 utterances that your users have made to your bot. You can use this list
1324 to tune the utterances that your bot responds to.
1325  
1326 For example, say that you have created a bot to order flowers. After
1327 your users have used your bot for a while, use the C<GetUtterancesView>
1328 operation to see the requests that they have made and whether they have
1329 been successful. You might find that the utterance "I want flowers" is
1330 not being recognized. You could add this utterance to the
1331 C<OrderFlowers> intent so that your bot recognizes that utterance.
1332  
1333 After you publish a new version of a bot, you can get information about
1334 the old version and the new so that you can compare the performance
1335 across the two versions.
1336  
1337 Utterance statistics are generated once a day. Data is available for
1338 the last 15 days. You can request information for up to 5 versions of
1339 your bot in each request. Amazon Lex returns the most frequent
1340 utterances received by the bot in the last 15 days. The response
1341 contains information about a maximum of 100 utterances for each
1342 version.
1343  
1344 If you set C<childDirected> field to true when you created your bot, or
1345 if you opted out of participating in improving Amazon Lex, utterances
1346 are not available.
1347  
1348 This operation requires permissions for the C<lex:GetUtterancesView>
1349 action.
1350  
1351  
1352 =head2 ListTagsForResource
1353  
1354 =over
1355  
1356 =item ResourceArn => Str
1357  
1358  
1359 =back
1360  
1361 Each argument is described in detail in: L<Paws::LexModels::ListTagsForResource>
1362  
1363 Returns: a L<Paws::LexModels::ListTagsForResourceResponse> instance
1364  
1365 Gets a list of tags associated with the specified resource. Only bots,
1366 bot aliases, and bot channels can have tags associated with them.
1367  
1368  
1369 =head2 PutBot
1370  
1371 =over
1372  
1373 =item ChildDirected => Bool
1374  
1375 =item Locale => Str
1376  
1377 =item Name => Str
1378  
1379 =item [AbortStatement => L<Paws::LexModels::Statement>]
1380  
1381 =item [Checksum => Str]
1382  
1383 =item [ClarificationPrompt => L<Paws::LexModels::Prompt>]
1384  
1385 =item [CreateVersion => Bool]
1386  
1387 =item [Description => Str]
1388  
1389 =item [DetectSentiment => Bool]
1390  
1391 =item [EnableModelImprovements => Bool]
1392  
1393 =item [IdleSessionTTLInSeconds => Int]
1394  
1395 =item [Intents => ArrayRef[L<Paws::LexModels::Intent>]]
1396  
1397 =item [NluIntentConfidenceThreshold => Num]
1398  
1399 =item [ProcessBehavior => Str]
1400  
1401 =item [Tags => ArrayRef[L<Paws::LexModels::Tag>]]
1402  
1403 =item [VoiceId => Str]
1404  
1405  
1406 =back
1407  
1408 Each argument is described in detail in: L<Paws::LexModels::PutBot>
1409  
1410 Returns: a L<Paws::LexModels::PutBotResponse> instance
1411  
1412 Creates an Amazon Lex conversational bot or replaces an existing bot.
1413 When you create or update a bot you are only required to specify a
1414 name, a locale, and whether the bot is directed toward children under
1415 age 13. You can use this to add intents later, or to remove intents
1416 from an existing bot. When you create a bot with the minimum
1417 information, the bot is created or updated but Amazon Lex returns the
1418 C< response C<FAILED>. You can build the bot after you add one or more
1419 intents. For more information about Amazon Lex bots, see how-it-works.>
1420  
1421 If you specify the name of an existing bot, the fields in the request
1422 replace the existing values in the C<$LATEST> version of the bot.
1423 Amazon Lex removes any fields that you don't provide values for in the
1424 request, except for the C<idleTTLInSeconds> and C<privacySettings>
1425 fields, which are set to their default values. If you don't specify
1426 values for required fields, Amazon Lex throws an exception.
1427  
1428 This operation requires permissions for the C<lex:PutBot> action. For
1429 more information, see security-iam.
1430  
1431  
1432 =head2 PutBotAlias
1433  
1434 =over
1435  
1436 =item BotName => Str
1437  
1438 =item BotVersion => Str
1439  
1440 =item Name => Str
1441  
1442 =item [Checksum => Str]
1443  
1444 =item [ConversationLogs => L<Paws::LexModels::ConversationLogsRequest>]
1445  
1446 =item [Description => Str]
1447  
1448 =item [Tags => ArrayRef[L<Paws::LexModels::Tag>]]
1449  
1450  
1451 =back
1452  
1453 Each argument is described in detail in: L<Paws::LexModels::PutBotAlias>
1454  
1455 Returns: a L<Paws::LexModels::PutBotAliasResponse> instance
1456  
1457 Creates an alias for the specified version of the bot or replaces an
1458 alias for the specified bot. To change the version of the bot that the
1459 alias points to, replace the alias. For more information about aliases,
1460 see versioning-aliases.
1461  
1462 This operation requires permissions for the C<lex:PutBotAlias> action.
1463  
1464  
1465 =head2 PutIntent
1466  
1467 =over
1468  
1469 =item Name => Str
1470  
1471 =item [Checksum => Str]
1472  
1473 =item [ConclusionStatement => L<Paws::LexModels::Statement>]
1474  
1475 =item [ConfirmationPrompt => L<Paws::LexModels::Prompt>]
1476  
1477 =item [CreateVersion => Bool]
1478  
1479 =item [Description => Str]
1480  
1481 =item [DialogCodeHook => L<Paws::LexModels::CodeHook>]
1482  
1483 =item [FollowUpPrompt => L<Paws::LexModels::FollowUpPrompt>]
1484  
1485 =item [FulfillmentActivity => L<Paws::LexModels::FulfillmentActivity>]
1486  
1487 =item [InputContexts => ArrayRef[L<Paws::LexModels::InputContext>]]
1488  
1489 =item [KendraConfiguration => L<Paws::LexModels::KendraConfiguration>]
1490  
1491 =item [OutputContexts => ArrayRef[L<Paws::LexModels::OutputContext>]]
1492  
1493 =item [ParentIntentSignature => Str]
1494  
1495 =item [RejectionStatement => L<Paws::LexModels::Statement>]
1496  
1497 =item [SampleUtterances => ArrayRef[Str|Undef]]
1498  
1499 =item [Slots => ArrayRef[L<Paws::LexModels::Slot>]]
1500  
1501  
1502 =back
1503  
1504 Each argument is described in detail in: L<Paws::LexModels::PutIntent>
1505  
1506 Returns: a L<Paws::LexModels::PutIntentResponse> instance
1507  
1508 Creates an intent or replaces an existing intent.
1509  
1510 To define the interaction between the user and your bot, you use one or
1511 more intents. For a pizza ordering bot, for example, you would create
1512 an C<OrderPizza> intent.
1513  
1514 To create an intent or replace an existing intent, you must provide the
1515 following:
1516  
1517 =over
1518  
1519 =item *
1520  
1521 Intent name. For example, C<OrderPizza>.
1522  
1523 =item *
1524  
1525 Sample utterances. For example, "Can I order a pizza, please." and "I
1526 want to order a pizza."
1527  
1528 =item *
1529  
1530 Information to be gathered. You specify slot types for the information
1531 that your bot will request from the user. You can specify standard slot
1532 types, such as a date or a time, or custom slot types such as the size
1533 and crust of a pizza.
1534  
1535 =item *
1536  
1537 How the intent will be fulfilled. You can provide a Lambda function or
1538 configure the intent to return the intent information to the client
1539 application. If you use a Lambda function, when all of the intent
1540 information is available, Amazon Lex invokes your Lambda function. If
1541 you configure your intent to return the intent information to the
1542 client application.
1543  
1544 =back
1545  
1546 You can specify other optional information in the request, such as:
1547  
1548 =over
1549  
1550 =item *
1551  
1552 A confirmation prompt to ask the user to confirm an intent. For
1553 example, "Shall I order your pizza?"
1554  
1555 =item *
1556  
1557 A conclusion statement to send to the user after the intent has been
1558 fulfilled. For example, "I placed your pizza order."
1559  
1560 =item *
1561  
1562 A follow-up prompt that asks the user for additional activity. For
1563 example, asking "Do you want to order a drink with your pizza?"
1564  
1565 =back
1566  
1567 If you specify an existing intent name to update the intent, Amazon Lex
1568 replaces the values in the C<$LATEST> version of the intent with the
1569 values in the request. Amazon Lex removes fields that you don't provide
1570 in the request. If you don't specify the required fields, Amazon Lex
1571 throws an exception. When you update the C<$LATEST> version of an
1572 intent, the C<status> field of any bot that uses the C<$LATEST> version
1573 of the intent is set to C<NOT_BUILT>.
1574  
1575 For more information, see how-it-works.
1576  
1577 This operation requires permissions for the C<lex:PutIntent> action.
1578  
1579  
1580 =head2 PutSlotType
1581  
1582 =over
1583  
1584 =item Name => Str
1585  
1586 =item [Checksum => Str]
1587  
1588 =item [CreateVersion => Bool]
1589  
1590 =item [Description => Str]
1591  
1592 =item [EnumerationValues => ArrayRef[L<Paws::LexModels::EnumerationValue>]]
1593  
1594 =item [ParentSlotTypeSignature => Str]
1595  
1596 =item [SlotTypeConfigurations => ArrayRef[L<Paws::LexModels::SlotTypeConfiguration>]]
1597  
1598 =item [ValueSelectionStrategy => Str]
1599  
1600  
1601 =back
1602  
1603 Each argument is described in detail in: L<Paws::LexModels::PutSlotType>
1604  
1605 Returns: a L<Paws::LexModels::PutSlotTypeResponse> instance
1606  
1607 Creates a custom slot type or replaces an existing custom slot type.
1608  
1609 To create a custom slot type, specify a name for the slot type and a
1610 set of enumeration values, which are the values that a slot of this
1611 type can assume. For more information, see how-it-works.
1612  
1613 If you specify the name of an existing slot type, the fields in the
1614 request replace the existing values in the C<$LATEST> version of the
1615 slot type. Amazon Lex removes the fields that you don't provide in the
1616 request. If you don't specify required fields, Amazon Lex throws an
1617 exception. When you update the C<$LATEST> version of a slot type, if a
1618 bot uses the C<$LATEST> version of an intent that contains the slot
1619 type, the bot's C<status> field is set to C<NOT_BUILT>.
1620  
1621 This operation requires permissions for the C<lex:PutSlotType> action.
1622  
1623  
1624 =head2 StartImport
1625  
1626 =over
1627  
1628 =item MergeStrategy => Str
1629  
1630 =item Payload => Str
1631  
1632 =item ResourceType => Str
1633  
1634 =item [Tags => ArrayRef[L<Paws::LexModels::Tag>]]
1635  
1636  
1637 =back
1638  
1639 Each argument is described in detail in: L<Paws::LexModels::StartImport>
1640  
1641 Returns: a L<Paws::LexModels::StartImportResponse> instance
1642  
1643 Starts a job to import a resource to Amazon Lex.
1644  
1645  
1646 =head2 TagResource
1647  
1648 =over
1649  
1650 =item ResourceArn => Str
1651  
1652 =item Tags => ArrayRef[L<Paws::LexModels::Tag>]
1653  
1654  
1655 =back
1656  
1657 Each argument is described in detail in: L<Paws::LexModels::TagResource>
1658  
1659 Returns: a L<Paws::LexModels::TagResourceResponse> instance
1660  
1661 Adds the specified tags to the specified resource. If a tag key already
1662 exists, the existing value is replaced with the new value.
1663  
1664  
1665 =head2 UntagResource
1666  
1667 =over
1668  
1669 =item ResourceArn => Str
1670  
1671 =item TagKeys => ArrayRef[Str|Undef]
1672  
1673  
1674 =back
1675  
1676 Each argument is described in detail in: L<Paws::LexModels::UntagResource>
1677  
1678 Returns: a L<Paws::LexModels::UntagResourceResponse> instance
1679  
1680 Removes tags from a bot, bot alias or bot channel.
1681  
1682  
1683  
1684  
1685 =head1 PAGINATORS
1686  
1687 Paginator methods are helpers that repetively call methods that return partial results
1688  
1689 =head2 GetAllBotAliases(sub { },BotName => Str, [MaxResults => Int, NameContains => Str, NextToken => Str])
1690  
1691 =head2 GetAllBotAliases(BotName => Str, [MaxResults => Int, NameContains => Str, NextToken => Str])
1692  
1693  
1694 If passed a sub as first parameter, it will call the sub for each element found in :
1695  
1696 - BotAliases, passing the object as the first parameter, and the string 'BotAliases' as the second parameter
1697  
1698 If not, it will return a a L<Paws::LexModels::GetBotAliasesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1699  
1700  
1701 =head2 GetAllBotChannelAssociations(sub { },BotAlias => Str, BotName => Str, [MaxResults => Int, NameContains => Str, NextToken => Str])
1702  
1703 =head2 GetAllBotChannelAssociations(BotAlias => Str, BotName => Str, [MaxResults => Int, NameContains => Str, NextToken => Str])
1704  
1705  
1706 If passed a sub as first parameter, it will call the sub for each element found in :
1707  
1708 - botChannelAssociations, passing the object as the first parameter, and the string 'botChannelAssociations' as the second parameter
1709  
1710 If not, it will return a a L<Paws::LexModels::GetBotChannelAssociationsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1711  
1712  
1713 =head2 GetAllBots(sub { },[MaxResults => Int, NameContains => Str, NextToken => Str])
1714  
1715 =head2 GetAllBots([MaxResults => Int, NameContains => Str, NextToken => Str])
1716  
1717  
1718 If passed a sub as first parameter, it will call the sub for each element found in :
1719  
1720 - bots, passing the object as the first parameter, and the string 'bots' as the second parameter
1721  
1722 If not, it will return a a L<Paws::LexModels::GetBotsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1723  
1724  
1725 =head2 GetAllBotVersions(sub { },Name => Str, [MaxResults => Int, NextToken => Str])
1726  
1727 =head2 GetAllBotVersions(Name => Str, [MaxResults => Int, NextToken => Str])
1728  
1729  
1730 If passed a sub as first parameter, it will call the sub for each element found in :
1731  
1732 - bots, passing the object as the first parameter, and the string 'bots' as the second parameter
1733  
1734 If not, it will return a a L<Paws::LexModels::GetBotVersionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1735  
1736  
1737 =head2 GetAllBuiltinIntents(sub { },[Locale => Str, MaxResults => Int, NextToken => Str, SignatureContains => Str])
1738  
1739 =head2 GetAllBuiltinIntents([Locale => Str, MaxResults => Int, NextToken => Str, SignatureContains => Str])
1740  
1741  
1742 If passed a sub as first parameter, it will call the sub for each element found in :
1743  
1744 - intents, passing the object as the first parameter, and the string 'intents' as the second parameter
1745  
1746 If not, it will return a a L<Paws::LexModels::GetBuiltinIntentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1747  
1748  
1749 =head2 GetAllBuiltinSlotTypes(sub { },[Locale => Str, MaxResults => Int, NextToken => Str, SignatureContains => Str])
1750  
1751 =head2 GetAllBuiltinSlotTypes([Locale => Str, MaxResults => Int, NextToken => Str, SignatureContains => Str])
1752  
1753  
1754 If passed a sub as first parameter, it will call the sub for each element found in :
1755  
1756 - slotTypes, passing the object as the first parameter, and the string 'slotTypes' as the second parameter
1757  
1758 If not, it will return a a L<Paws::LexModels::GetBuiltinSlotTypesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1759  
1760  
1761 =head2 GetAllIntents(sub { },[MaxResults => Int, NameContains => Str, NextToken => Str])
1762  
1763 =head2 GetAllIntents([MaxResults => Int, NameContains => Str, NextToken => Str])
1764  
1765  
1766 If passed a sub as first parameter, it will call the sub for each element found in :
1767  
1768 - intents, passing the object as the first parameter, and the string 'intents' as the second parameter
1769  
1770 If not, it will return a a L<Paws::LexModels::GetIntentsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1771  
1772  
1773 =head2 GetAllIntentVersions(sub { },Name => Str, [MaxResults => Int, NextToken => Str])
1774  
1775 =head2 GetAllIntentVersions(Name => Str, [MaxResults => Int, NextToken => Str])
1776  
1777  
1778 If passed a sub as first parameter, it will call the sub for each element found in :
1779  
1780 - intents, passing the object as the first parameter, and the string 'intents' as the second parameter
1781  
1782 If not, it will return a a L<Paws::LexModels::GetIntentVersionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1783  
1784  
1785 =head2 GetAllSlotTypes(sub { },[MaxResults => Int, NameContains => Str, NextToken => Str])
1786  
1787 =head2 GetAllSlotTypes([MaxResults => Int, NameContains => Str, NextToken => Str])
1788  
1789  
1790 If passed a sub as first parameter, it will call the sub for each element found in :
1791  
1792 - slotTypes, passing the object as the first parameter, and the string 'slotTypes' as the second parameter
1793  
1794 If not, it will return a a L<Paws::LexModels::GetSlotTypesResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1795  
1796  
1797 =head2 GetAllSlotTypeVersions(sub { },Name => Str, [MaxResults => Int, NextToken => Str])
1798  
1799 =head2 GetAllSlotTypeVersions(Name => Str, [MaxResults => Int, NextToken => Str])
1800  
1801  
1802 If passed a sub as first parameter, it will call the sub for each element found in :
1803  
1804 - slotTypes, passing the object as the first parameter, and the string 'slotTypes' as the second parameter
1805  
1806 If not, it will return a a L<Paws::LexModels::GetSlotTypeVersionsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
1807  
1808  
1809  
1810  
1811  
1812 =head1 SEE ALSO
1813  
1814 This service class forms part of L<Paws>
1815  
1816 =head1 BUGS and CONTRIBUTIONS
1817  
1818 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
1819  
1820 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
1821  
1822 =cut
1823