File Coverage

blib/lib/Paws/WAF.pm
Criterion Covered Total %
statement 7 269 2.6
branch 0 28 0.0
condition n/a
subroutine 3 58 5.1
pod 51 56 91.0
total 61 411 14.8


line stmt bran cond sub pod time code
1             package Paws::WAF;
2 1     1   3910 use Moose;
  1     1   4  
  1         13  
  1         2295  
  1         5  
  1         17  
3 1     1 0 4 sub service { 'waf' }
4 0     0 0   sub version { '2015-08-24' }
5 0     0 0   sub target_prefix { 'AWSWAF_20150824' }
6 0     0 0   sub json_version { "1.1" }
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::JsonCaller', 'Paws::Net::JsonResponse';
15              
16             has '+region_rules' => (default => sub {
17             my $regioninfo;
18             $regioninfo = [
19             {
20             constraints => [
21             [
22             'region',
23             'notStartsWith',
24             'cn-'
25             ]
26             ],
27             properties => {
28             credentialScope => {
29             region => 'us-east-1'
30             }
31             },
32             uri => 'https://waf.amazonaws.com'
33             }
34             ];
35              
36             return $regioninfo;
37             });
38              
39            
40             sub CreateByteMatchSet {
41 0     0 1   my $self = shift;
42 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateByteMatchSet', @_);
43 0           return $self->caller->do_call($self, $call_object);
44             }
45             sub CreateIPSet {
46 0     0 1   my $self = shift;
47 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateIPSet', @_);
48 0           return $self->caller->do_call($self, $call_object);
49             }
50             sub CreateRateBasedRule {
51 0     0 1   my $self = shift;
52 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateRateBasedRule', @_);
53 0           return $self->caller->do_call($self, $call_object);
54             }
55             sub CreateRule {
56 0     0 1   my $self = shift;
57 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateRule', @_);
58 0           return $self->caller->do_call($self, $call_object);
59             }
60             sub CreateSizeConstraintSet {
61 0     0 1   my $self = shift;
62 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateSizeConstraintSet', @_);
63 0           return $self->caller->do_call($self, $call_object);
64             }
65             sub CreateSqlInjectionMatchSet {
66 0     0 1   my $self = shift;
67 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateSqlInjectionMatchSet', @_);
68 0           return $self->caller->do_call($self, $call_object);
69             }
70             sub CreateWebACL {
71 0     0 1   my $self = shift;
72 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateWebACL', @_);
73 0           return $self->caller->do_call($self, $call_object);
74             }
75             sub CreateXssMatchSet {
76 0     0 1   my $self = shift;
77 0           my $call_object = $self->new_with_coercions('Paws::WAF::CreateXssMatchSet', @_);
78 0           return $self->caller->do_call($self, $call_object);
79             }
80             sub DeleteByteMatchSet {
81 0     0 1   my $self = shift;
82 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteByteMatchSet', @_);
83 0           return $self->caller->do_call($self, $call_object);
84             }
85             sub DeleteIPSet {
86 0     0 1   my $self = shift;
87 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteIPSet', @_);
88 0           return $self->caller->do_call($self, $call_object);
89             }
90             sub DeleteRateBasedRule {
91 0     0 1   my $self = shift;
92 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteRateBasedRule', @_);
93 0           return $self->caller->do_call($self, $call_object);
94             }
95             sub DeleteRule {
96 0     0 1   my $self = shift;
97 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteRule', @_);
98 0           return $self->caller->do_call($self, $call_object);
99             }
100             sub DeleteSizeConstraintSet {
101 0     0 1   my $self = shift;
102 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteSizeConstraintSet', @_);
103 0           return $self->caller->do_call($self, $call_object);
104             }
105             sub DeleteSqlInjectionMatchSet {
106 0     0 1   my $self = shift;
107 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteSqlInjectionMatchSet', @_);
108 0           return $self->caller->do_call($self, $call_object);
109             }
110             sub DeleteWebACL {
111 0     0 1   my $self = shift;
112 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteWebACL', @_);
113 0           return $self->caller->do_call($self, $call_object);
114             }
115             sub DeleteXssMatchSet {
116 0     0 1   my $self = shift;
117 0           my $call_object = $self->new_with_coercions('Paws::WAF::DeleteXssMatchSet', @_);
118 0           return $self->caller->do_call($self, $call_object);
119             }
120             sub GetByteMatchSet {
121 0     0 1   my $self = shift;
122 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetByteMatchSet', @_);
123 0           return $self->caller->do_call($self, $call_object);
124             }
125             sub GetChangeToken {
126 0     0 1   my $self = shift;
127 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetChangeToken', @_);
128 0           return $self->caller->do_call($self, $call_object);
129             }
130             sub GetChangeTokenStatus {
131 0     0 1   my $self = shift;
132 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetChangeTokenStatus', @_);
133 0           return $self->caller->do_call($self, $call_object);
134             }
135             sub GetIPSet {
136 0     0 1   my $self = shift;
137 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetIPSet', @_);
138 0           return $self->caller->do_call($self, $call_object);
139             }
140             sub GetRateBasedRule {
141 0     0 1   my $self = shift;
142 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetRateBasedRule', @_);
143 0           return $self->caller->do_call($self, $call_object);
144             }
145             sub GetRateBasedRuleManagedKeys {
146 0     0 1   my $self = shift;
147 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetRateBasedRuleManagedKeys', @_);
148 0           return $self->caller->do_call($self, $call_object);
149             }
150             sub GetRule {
151 0     0 1   my $self = shift;
152 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetRule', @_);
153 0           return $self->caller->do_call($self, $call_object);
154             }
155             sub GetSampledRequests {
156 0     0 1   my $self = shift;
157 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetSampledRequests', @_);
158 0           return $self->caller->do_call($self, $call_object);
159             }
160             sub GetSizeConstraintSet {
161 0     0 1   my $self = shift;
162 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetSizeConstraintSet', @_);
163 0           return $self->caller->do_call($self, $call_object);
164             }
165             sub GetSqlInjectionMatchSet {
166 0     0 1   my $self = shift;
167 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetSqlInjectionMatchSet', @_);
168 0           return $self->caller->do_call($self, $call_object);
169             }
170             sub GetWebACL {
171 0     0 1   my $self = shift;
172 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetWebACL', @_);
173 0           return $self->caller->do_call($self, $call_object);
174             }
175             sub GetXssMatchSet {
176 0     0 1   my $self = shift;
177 0           my $call_object = $self->new_with_coercions('Paws::WAF::GetXssMatchSet', @_);
178 0           return $self->caller->do_call($self, $call_object);
179             }
180             sub ListByteMatchSets {
181 0     0 1   my $self = shift;
182 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListByteMatchSets', @_);
183 0           return $self->caller->do_call($self, $call_object);
184             }
185             sub ListIPSets {
186 0     0 1   my $self = shift;
187 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListIPSets', @_);
188 0           return $self->caller->do_call($self, $call_object);
189             }
190             sub ListRateBasedRules {
191 0     0 1   my $self = shift;
192 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListRateBasedRules', @_);
193 0           return $self->caller->do_call($self, $call_object);
194             }
195             sub ListRules {
196 0     0 1   my $self = shift;
197 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListRules', @_);
198 0           return $self->caller->do_call($self, $call_object);
199             }
200             sub ListSizeConstraintSets {
201 0     0 1   my $self = shift;
202 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListSizeConstraintSets', @_);
203 0           return $self->caller->do_call($self, $call_object);
204             }
205             sub ListSqlInjectionMatchSets {
206 0     0 1   my $self = shift;
207 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListSqlInjectionMatchSets', @_);
208 0           return $self->caller->do_call($self, $call_object);
209             }
210             sub ListWebACLs {
211 0     0 1   my $self = shift;
212 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListWebACLs', @_);
213 0           return $self->caller->do_call($self, $call_object);
214             }
215             sub ListXssMatchSets {
216 0     0 1   my $self = shift;
217 0           my $call_object = $self->new_with_coercions('Paws::WAF::ListXssMatchSets', @_);
218 0           return $self->caller->do_call($self, $call_object);
219             }
220             sub UpdateByteMatchSet {
221 0     0 1   my $self = shift;
222 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateByteMatchSet', @_);
223 0           return $self->caller->do_call($self, $call_object);
224             }
225             sub UpdateIPSet {
226 0     0 1   my $self = shift;
227 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateIPSet', @_);
228 0           return $self->caller->do_call($self, $call_object);
229             }
230             sub UpdateRateBasedRule {
231 0     0 1   my $self = shift;
232 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateRateBasedRule', @_);
233 0           return $self->caller->do_call($self, $call_object);
234             }
235             sub UpdateRule {
236 0     0 1   my $self = shift;
237 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateRule', @_);
238 0           return $self->caller->do_call($self, $call_object);
239             }
240             sub UpdateSizeConstraintSet {
241 0     0 1   my $self = shift;
242 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateSizeConstraintSet', @_);
243 0           return $self->caller->do_call($self, $call_object);
244             }
245             sub UpdateSqlInjectionMatchSet {
246 0     0 1   my $self = shift;
247 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateSqlInjectionMatchSet', @_);
248 0           return $self->caller->do_call($self, $call_object);
249             }
250             sub UpdateWebACL {
251 0     0 1   my $self = shift;
252 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateWebACL', @_);
253 0           return $self->caller->do_call($self, $call_object);
254             }
255             sub UpdateXssMatchSet {
256 0     0 1   my $self = shift;
257 0           my $call_object = $self->new_with_coercions('Paws::WAF::UpdateXssMatchSet', @_);
258 0           return $self->caller->do_call($self, $call_object);
259             }
260            
261             sub ListAllByteMatchSets {
262 0     0 1   my $self = shift;
263              
264 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
265 0           my $result = $self->ListByteMatchSets(@_);
266 0           my $next_result = $result;
267              
268 0 0         if (not defined $callback) {
269 0           while ($next_result->NextMarker) {
270 0           $next_result = $self->ListByteMatchSets(@_, NextMarker => $next_result->NextMarker);
271 0           push @{ $result->ByteMatchSets }, @{ $next_result->ByteMatchSets };
  0            
  0            
272             }
273 0           return $result;
274             } else {
275 0           while ($result->NextMarker) {
276 0           $callback->($_ => 'ByteMatchSets') foreach (@{ $result->ByteMatchSets });
  0            
277 0           $result = $self->ListByteMatchSets(@_, NextMarker => $result->NextMarker);
278             }
279 0           $callback->($_ => 'ByteMatchSets') foreach (@{ $result->ByteMatchSets });
  0            
280             }
281              
282             return undef
283 0           }
284             sub ListAllIPSets {
285 0     0 1   my $self = shift;
286              
287 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
288 0           my $result = $self->ListIPSets(@_);
289 0           my $next_result = $result;
290              
291 0 0         if (not defined $callback) {
292 0           while ($next_result->NextMarker) {
293 0           $next_result = $self->ListIPSets(@_, NextMarker => $next_result->NextMarker);
294 0           push @{ $result->IPSets }, @{ $next_result->IPSets };
  0            
  0            
295             }
296 0           return $result;
297             } else {
298 0           while ($result->NextMarker) {
299 0           $callback->($_ => 'IPSets') foreach (@{ $result->IPSets });
  0            
300 0           $result = $self->ListIPSets(@_, NextMarker => $result->NextMarker);
301             }
302 0           $callback->($_ => 'IPSets') foreach (@{ $result->IPSets });
  0            
303             }
304              
305             return undef
306 0           }
307             sub ListAllRules {
308 0     0 1   my $self = shift;
309              
310 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
311 0           my $result = $self->ListRules(@_);
312 0           my $next_result = $result;
313              
314 0 0         if (not defined $callback) {
315 0           while ($next_result->NextMarker) {
316 0           $next_result = $self->ListRules(@_, NextMarker => $next_result->NextMarker);
317 0           push @{ $result->Rules }, @{ $next_result->Rules };
  0            
  0            
318             }
319 0           return $result;
320             } else {
321 0           while ($result->NextMarker) {
322 0           $callback->($_ => 'Rules') foreach (@{ $result->Rules });
  0            
323 0           $result = $self->ListRules(@_, NextMarker => $result->NextMarker);
324             }
325 0           $callback->($_ => 'Rules') foreach (@{ $result->Rules });
  0            
326             }
327              
328             return undef
329 0           }
330             sub ListAllSizeConstraintSets {
331 0     0 1   my $self = shift;
332              
333 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
334 0           my $result = $self->ListSizeConstraintSets(@_);
335 0           my $next_result = $result;
336              
337 0 0         if (not defined $callback) {
338 0           while ($next_result->NextMarker) {
339 0           $next_result = $self->ListSizeConstraintSets(@_, NextMarker => $next_result->NextMarker);
340 0           push @{ $result->SizeConstraintSets }, @{ $next_result->SizeConstraintSets };
  0            
  0            
341             }
342 0           return $result;
343             } else {
344 0           while ($result->NextMarker) {
345 0           $callback->($_ => 'SizeConstraintSets') foreach (@{ $result->SizeConstraintSets });
  0            
346 0           $result = $self->ListSizeConstraintSets(@_, NextMarker => $result->NextMarker);
347             }
348 0           $callback->($_ => 'SizeConstraintSets') foreach (@{ $result->SizeConstraintSets });
  0            
349             }
350              
351             return undef
352 0           }
353             sub ListAllSqlInjectionMatchSets {
354 0     0 1   my $self = shift;
355              
356 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
357 0           my $result = $self->ListSqlInjectionMatchSets(@_);
358 0           my $next_result = $result;
359              
360 0 0         if (not defined $callback) {
361 0           while ($next_result->NextMarker) {
362 0           $next_result = $self->ListSqlInjectionMatchSets(@_, NextMarker => $next_result->NextMarker);
363 0           push @{ $result->SqlInjectionMatchSets }, @{ $next_result->SqlInjectionMatchSets };
  0            
  0            
364             }
365 0           return $result;
366             } else {
367 0           while ($result->NextMarker) {
368 0           $callback->($_ => 'SqlInjectionMatchSets') foreach (@{ $result->SqlInjectionMatchSets });
  0            
369 0           $result = $self->ListSqlInjectionMatchSets(@_, NextMarker => $result->NextMarker);
370             }
371 0           $callback->($_ => 'SqlInjectionMatchSets') foreach (@{ $result->SqlInjectionMatchSets });
  0            
372             }
373              
374             return undef
375 0           }
376             sub ListAllWebACLs {
377 0     0 1   my $self = shift;
378              
379 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
380 0           my $result = $self->ListWebACLs(@_);
381 0           my $next_result = $result;
382              
383 0 0         if (not defined $callback) {
384 0           while ($next_result->NextMarker) {
385 0           $next_result = $self->ListWebACLs(@_, NextMarker => $next_result->NextMarker);
386 0           push @{ $result->WebACLs }, @{ $next_result->WebACLs };
  0            
  0            
387             }
388 0           return $result;
389             } else {
390 0           while ($result->NextMarker) {
391 0           $callback->($_ => 'WebACLs') foreach (@{ $result->WebACLs });
  0            
392 0           $result = $self->ListWebACLs(@_, NextMarker => $result->NextMarker);
393             }
394 0           $callback->($_ => 'WebACLs') foreach (@{ $result->WebACLs });
  0            
395             }
396              
397             return undef
398 0           }
399             sub ListAllXssMatchSets {
400 0     0 1   my $self = shift;
401              
402 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
403 0           my $result = $self->ListXssMatchSets(@_);
404 0           my $next_result = $result;
405              
406 0 0         if (not defined $callback) {
407 0           while ($next_result->NextMarker) {
408 0           $next_result = $self->ListXssMatchSets(@_, NextMarker => $next_result->NextMarker);
409 0           push @{ $result->XssMatchSets }, @{ $next_result->XssMatchSets };
  0            
  0            
410             }
411 0           return $result;
412             } else {
413 0           while ($result->NextMarker) {
414 0           $callback->($_ => 'XssMatchSets') foreach (@{ $result->XssMatchSets });
  0            
415 0           $result = $self->ListXssMatchSets(@_, NextMarker => $result->NextMarker);
416             }
417 0           $callback->($_ => 'XssMatchSets') foreach (@{ $result->XssMatchSets });
  0            
418             }
419              
420             return undef
421 0           }
422              
423              
424 0     0 0   sub operations { qw/CreateByteMatchSet CreateIPSet CreateRateBasedRule CreateRule CreateSizeConstraintSet CreateSqlInjectionMatchSet CreateWebACL CreateXssMatchSet DeleteByteMatchSet DeleteIPSet DeleteRateBasedRule DeleteRule DeleteSizeConstraintSet DeleteSqlInjectionMatchSet DeleteWebACL DeleteXssMatchSet GetByteMatchSet GetChangeToken GetChangeTokenStatus GetIPSet GetRateBasedRule GetRateBasedRuleManagedKeys GetRule GetSampledRequests GetSizeConstraintSet GetSqlInjectionMatchSet GetWebACL GetXssMatchSet ListByteMatchSets ListIPSets ListRateBasedRules ListRules ListSizeConstraintSets ListSqlInjectionMatchSets ListWebACLs ListXssMatchSets UpdateByteMatchSet UpdateIPSet UpdateRateBasedRule UpdateRule UpdateSizeConstraintSet UpdateSqlInjectionMatchSet UpdateWebACL UpdateXssMatchSet / }
425              
426             1;
427              
428             ### main pod documentation begin ###
429              
430             =head1 NAME
431              
432             Paws::WAF - Perl Interface to AWS AWS WAF
433              
434             =head1 SYNOPSIS
435              
436             use Paws;
437              
438             my $obj = Paws->service('WAF');
439             my $res = $obj->Method(
440             Arg1 => $val1,
441             Arg2 => [ 'V1', 'V2' ],
442             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
443             # of the arguments type
444             Arg3 => { Att1 => 'Val1' },
445             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
446             # the constructor of the arguments type
447             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
448             );
449              
450             =head1 DESCRIPTION
451              
452             This is the I<AWS WAF API Reference> for using AWS WAF with Amazon
453             CloudFront. The AWS WAF actions and data types listed in the reference
454             are available for protecting Amazon CloudFront distributions. You can
455             use these actions and data types via the endpoint I<waf.amazonaws.com>.
456             This guide is for developers who need detailed information about the
457             AWS WAF API actions, data types, and errors. For detailed information
458             about AWS WAF features and an overview of how to use the AWS WAF API,
459             see the AWS WAF Developer Guide.
460              
461             =head1 METHODS
462              
463             =head2 CreateByteMatchSet(ChangeToken => Str, Name => Str)
464              
465             Each argument is described in detail in: L<Paws::WAF::CreateByteMatchSet>
466              
467             Returns: a L<Paws::WAF::CreateByteMatchSetResponse> instance
468              
469             Creates a C<ByteMatchSet>. You then use UpdateByteMatchSet to identify
470             the part of a web request that you want AWS WAF to inspect, such as the
471             values of the C<User-Agent> header or the query string. For example,
472             you can create a C<ByteMatchSet> that matches any requests with
473             C<User-Agent> headers that contain the string C<BadBot>. You can then
474             configure AWS WAF to reject those requests.
475              
476             To create and configure a C<ByteMatchSet>, perform the following steps:
477              
478             =over
479              
480             =item 1.
481              
482             Use GetChangeToken to get the change token that you provide in the
483             C<ChangeToken> parameter of a C<CreateByteMatchSet> request.
484              
485             =item 2.
486              
487             Submit a C<CreateByteMatchSet> request.
488              
489             =item 3.
490              
491             Use C<GetChangeToken> to get the change token that you provide in the
492             C<ChangeToken> parameter of an C<UpdateByteMatchSet> request.
493              
494             =item 4.
495              
496             Submit an UpdateByteMatchSet request to specify the part of the request
497             that you want AWS WAF to inspect (for example, the header or the URI)
498             and the value that you want AWS WAF to watch for.
499              
500             =back
501              
502             For more information about how to use the AWS WAF API to allow or block
503             HTTP requests, see the AWS WAF Developer Guide.
504              
505              
506             =head2 CreateIPSet(ChangeToken => Str, Name => Str)
507              
508             Each argument is described in detail in: L<Paws::WAF::CreateIPSet>
509              
510             Returns: a L<Paws::WAF::CreateIPSetResponse> instance
511              
512             Creates an IPSet, which you use to specify which web requests you want
513             to allow or block based on the IP addresses that the requests originate
514             from. For example, if you're receiving a lot of requests from one or
515             more individual IP addresses or one or more ranges of IP addresses and
516             you want to block the requests, you can create an C<IPSet> that
517             contains those IP addresses and then configure AWS WAF to block the
518             requests.
519              
520             To create and configure an C<IPSet>, perform the following steps:
521              
522             =over
523              
524             =item 1.
525              
526             Use GetChangeToken to get the change token that you provide in the
527             C<ChangeToken> parameter of a C<CreateIPSet> request.
528              
529             =item 2.
530              
531             Submit a C<CreateIPSet> request.
532              
533             =item 3.
534              
535             Use C<GetChangeToken> to get the change token that you provide in the
536             C<ChangeToken> parameter of an UpdateIPSet request.
537              
538             =item 4.
539              
540             Submit an C<UpdateIPSet> request to specify the IP addresses that you
541             want AWS WAF to watch for.
542              
543             =back
544              
545             For more information about how to use the AWS WAF API to allow or block
546             HTTP requests, see the AWS WAF Developer Guide.
547              
548              
549             =head2 CreateRateBasedRule(ChangeToken => Str, MetricName => Str, Name => Str, RateKey => Str, RateLimit => Int)
550              
551             Each argument is described in detail in: L<Paws::WAF::CreateRateBasedRule>
552              
553             Returns: a L<Paws::WAF::CreateRateBasedRuleResponse> instance
554              
555             Creates a RateBasedRule. The C<RateBasedRule> contains a C<RateLimit>,
556             which specifies the maximum number of requests that AWS WAF allows from
557             a specified IP address in a five-minute period. The C<RateBasedRule>
558             also contains the C<IPSet> objects, C<ByteMatchSet> objects, and other
559             predicates that identify the requests that you want to count or block
560             if these requests exceed the C<RateLimit>.
561              
562             If you add more than one predicate to a C<RateBasedRule>, a request not
563             only must exceed the C<RateLimit>, but it also must match all the
564             specifications to be counted or blocked. For example, suppose you add
565             the following to a C<RateBasedRule>:
566              
567             =over
568              
569             =item *
570              
571             An C<IPSet> that matches the IP address C<192.0.2.44/32>
572              
573             =item *
574              
575             A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
576              
577             =back
578              
579             Further, you specify a C<RateLimit> of 15,000.
580              
581             You then add the C<RateBasedRule> to a C<WebACL> and specify that you
582             want to block requests that meet the conditions in the rule. For a
583             request to be blocked, it must come from the IP address 192.0.2.44
584             I<and> the C<User-Agent> header in the request must contain the value
585             C<BadBot>. Further, requests that match these two conditions must be
586             received at a rate of more than 15,000 requests every five minutes. If
587             both conditions are met and the rate is exceeded, AWS WAF blocks the
588             requests. If the rate drops below 15,000 for a five-minute period, AWS
589             WAF no longer blocks the requests.
590              
591             As a second example, suppose you want to limit requests to a particular
592             page on your site. To do this, you could add the following to a
593             C<RateBasedRule>:
594              
595             =over
596              
597             =item *
598              
599             A C<ByteMatchSet> with C<FieldToMatch> of C<URI>
600              
601             =item *
602              
603             A C<PositionalConstraint> of C<STARTS_WITH>
604              
605             =item *
606              
607             A C<TargetString> of C<login>
608              
609             =back
610              
611             Further, you specify a C<RateLimit> of 15,000.
612              
613             By adding this C<RateBasedRule> to a C<WebACL>, you could limit
614             requests to your login page without affecting the rest of your site.
615              
616             To create and configure a C<RateBasedRule>, perform the following
617             steps:
618              
619             =over
620              
621             =item 1.
622              
623             Create and update the predicates that you want to include in the rule.
624             For more information, see CreateByteMatchSet, CreateIPSet, and
625             CreateSqlInjectionMatchSet.
626              
627             =item 2.
628              
629             Use GetChangeToken to get the change token that you provide in the
630             C<ChangeToken> parameter of a C<CreateRule> request.
631              
632             =item 3.
633              
634             Submit a C<CreateRateBasedRule> request.
635              
636             =item 4.
637              
638             Use C<GetChangeToken> to get the change token that you provide in the
639             C<ChangeToken> parameter of an UpdateRule request.
640              
641             =item 5.
642              
643             Submit an C<UpdateRateBasedRule> request to specify the predicates that
644             you want to include in the rule.
645              
646             =item 6.
647              
648             Create and update a C<WebACL> that contains the C<RateBasedRule>. For
649             more information, see CreateWebACL.
650              
651             =back
652              
653             For more information about how to use the AWS WAF API to allow or block
654             HTTP requests, see the AWS WAF Developer Guide.
655              
656              
657             =head2 CreateRule(ChangeToken => Str, MetricName => Str, Name => Str)
658              
659             Each argument is described in detail in: L<Paws::WAF::CreateRule>
660              
661             Returns: a L<Paws::WAF::CreateRuleResponse> instance
662              
663             Creates a C<Rule>, which contains the C<IPSet> objects, C<ByteMatchSet>
664             objects, and other predicates that identify the requests that you want
665             to block. If you add more than one predicate to a C<Rule>, a request
666             must match all of the specifications to be allowed or blocked. For
667             example, suppose you add the following to a C<Rule>:
668              
669             =over
670              
671             =item *
672              
673             An C<IPSet> that matches the IP address C<192.0.2.44/32>
674              
675             =item *
676              
677             A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
678              
679             =back
680              
681             You then add the C<Rule> to a C<WebACL> and specify that you want to
682             blocks requests that satisfy the C<Rule>. For a request to be blocked,
683             it must come from the IP address 192.0.2.44 I<and> the C<User-Agent>
684             header in the request must contain the value C<BadBot>.
685              
686             To create and configure a C<Rule>, perform the following steps:
687              
688             =over
689              
690             =item 1.
691              
692             Create and update the predicates that you want to include in the
693             C<Rule>. For more information, see CreateByteMatchSet, CreateIPSet, and
694             CreateSqlInjectionMatchSet.
695              
696             =item 2.
697              
698             Use GetChangeToken to get the change token that you provide in the
699             C<ChangeToken> parameter of a C<CreateRule> request.
700              
701             =item 3.
702              
703             Submit a C<CreateRule> request.
704              
705             =item 4.
706              
707             Use C<GetChangeToken> to get the change token that you provide in the
708             C<ChangeToken> parameter of an UpdateRule request.
709              
710             =item 5.
711              
712             Submit an C<UpdateRule> request to specify the predicates that you want
713             to include in the C<Rule>.
714              
715             =item 6.
716              
717             Create and update a C<WebACL> that contains the C<Rule>. For more
718             information, see CreateWebACL.
719              
720             =back
721              
722             For more information about how to use the AWS WAF API to allow or block
723             HTTP requests, see the AWS WAF Developer Guide.
724              
725              
726             =head2 CreateSizeConstraintSet(ChangeToken => Str, Name => Str)
727              
728             Each argument is described in detail in: L<Paws::WAF::CreateSizeConstraintSet>
729              
730             Returns: a L<Paws::WAF::CreateSizeConstraintSetResponse> instance
731              
732             Creates a C<SizeConstraintSet>. You then use UpdateSizeConstraintSet to
733             identify the part of a web request that you want AWS WAF to check for
734             length, such as the length of the C<User-Agent> header or the length of
735             the query string. For example, you can create a C<SizeConstraintSet>
736             that matches any requests that have a query string that is longer than
737             100 bytes. You can then configure AWS WAF to reject those requests.
738              
739             To create and configure a C<SizeConstraintSet>, perform the following
740             steps:
741              
742             =over
743              
744             =item 1.
745              
746             Use GetChangeToken to get the change token that you provide in the
747             C<ChangeToken> parameter of a C<CreateSizeConstraintSet> request.
748              
749             =item 2.
750              
751             Submit a C<CreateSizeConstraintSet> request.
752              
753             =item 3.
754              
755             Use C<GetChangeToken> to get the change token that you provide in the
756             C<ChangeToken> parameter of an C<UpdateSizeConstraintSet> request.
757              
758             =item 4.
759              
760             Submit an UpdateSizeConstraintSet request to specify the part of the
761             request that you want AWS WAF to inspect (for example, the header or
762             the URI) and the value that you want AWS WAF to watch for.
763              
764             =back
765              
766             For more information about how to use the AWS WAF API to allow or block
767             HTTP requests, see the AWS WAF Developer Guide.
768              
769              
770             =head2 CreateSqlInjectionMatchSet(ChangeToken => Str, Name => Str)
771              
772             Each argument is described in detail in: L<Paws::WAF::CreateSqlInjectionMatchSet>
773              
774             Returns: a L<Paws::WAF::CreateSqlInjectionMatchSetResponse> instance
775              
776             Creates a SqlInjectionMatchSet, which you use to allow, block, or count
777             requests that contain snippets of SQL code in a specified part of web
778             requests. AWS WAF searches for character sequences that are likely to
779             be malicious strings.
780              
781             To create and configure a C<SqlInjectionMatchSet>, perform the
782             following steps:
783              
784             =over
785              
786             =item 1.
787              
788             Use GetChangeToken to get the change token that you provide in the
789             C<ChangeToken> parameter of a C<CreateSqlInjectionMatchSet> request.
790              
791             =item 2.
792              
793             Submit a C<CreateSqlInjectionMatchSet> request.
794              
795             =item 3.
796              
797             Use C<GetChangeToken> to get the change token that you provide in the
798             C<ChangeToken> parameter of an UpdateSqlInjectionMatchSet request.
799              
800             =item 4.
801              
802             Submit an UpdateSqlInjectionMatchSet request to specify the parts of
803             web requests in which you want to allow, block, or count malicious SQL
804             code.
805              
806             =back
807              
808             For more information about how to use the AWS WAF API to allow or block
809             HTTP requests, see the AWS WAF Developer Guide.
810              
811              
812             =head2 CreateWebACL(ChangeToken => Str, DefaultAction => L<Paws::WAF::WafAction>, MetricName => Str, Name => Str)
813              
814             Each argument is described in detail in: L<Paws::WAF::CreateWebACL>
815              
816             Returns: a L<Paws::WAF::CreateWebACLResponse> instance
817              
818             Creates a C<WebACL>, which contains the C<Rules> that identify the
819             CloudFront web requests that you want to allow, block, or count. AWS
820             WAF evaluates C<Rules> in order based on the value of C<Priority> for
821             each C<Rule>.
822              
823             You also specify a default action, either C<ALLOW> or C<BLOCK>. If a
824             web request doesn't match any of the C<Rules> in a C<WebACL>, AWS WAF
825             responds to the request with the default action.
826              
827             To create and configure a C<WebACL>, perform the following steps:
828              
829             =over
830              
831             =item 1.
832              
833             Create and update the C<ByteMatchSet> objects and other predicates that
834             you want to include in C<Rules>. For more information, see
835             CreateByteMatchSet, UpdateByteMatchSet, CreateIPSet, UpdateIPSet,
836             CreateSqlInjectionMatchSet, and UpdateSqlInjectionMatchSet.
837              
838             =item 2.
839              
840             Create and update the C<Rules> that you want to include in the
841             C<WebACL>. For more information, see CreateRule and UpdateRule.
842              
843             =item 3.
844              
845             Use GetChangeToken to get the change token that you provide in the
846             C<ChangeToken> parameter of a C<CreateWebACL> request.
847              
848             =item 4.
849              
850             Submit a C<CreateWebACL> request.
851              
852             =item 5.
853              
854             Use C<GetChangeToken> to get the change token that you provide in the
855             C<ChangeToken> parameter of an UpdateWebACL request.
856              
857             =item 6.
858              
859             Submit an UpdateWebACL request to specify the C<Rules> that you want to
860             include in the C<WebACL>, to specify the default action, and to
861             associate the C<WebACL> with a CloudFront distribution.
862              
863             =back
864              
865             For more information about how to use the AWS WAF API, see the AWS WAF
866             Developer Guide.
867              
868              
869             =head2 CreateXssMatchSet(ChangeToken => Str, Name => Str)
870              
871             Each argument is described in detail in: L<Paws::WAF::CreateXssMatchSet>
872              
873             Returns: a L<Paws::WAF::CreateXssMatchSetResponse> instance
874              
875             Creates an XssMatchSet, which you use to allow, block, or count
876             requests that contain cross-site scripting attacks in the specified
877             part of web requests. AWS WAF searches for character sequences that are
878             likely to be malicious strings.
879              
880             To create and configure an C<XssMatchSet>, perform the following steps:
881              
882             =over
883              
884             =item 1.
885              
886             Use GetChangeToken to get the change token that you provide in the
887             C<ChangeToken> parameter of a C<CreateXssMatchSet> request.
888              
889             =item 2.
890              
891             Submit a C<CreateXssMatchSet> request.
892              
893             =item 3.
894              
895             Use C<GetChangeToken> to get the change token that you provide in the
896             C<ChangeToken> parameter of an UpdateXssMatchSet request.
897              
898             =item 4.
899              
900             Submit an UpdateXssMatchSet request to specify the parts of web
901             requests in which you want to allow, block, or count cross-site
902             scripting attacks.
903              
904             =back
905              
906             For more information about how to use the AWS WAF API to allow or block
907             HTTP requests, see the AWS WAF Developer Guide.
908              
909              
910             =head2 DeleteByteMatchSet(ByteMatchSetId => Str, ChangeToken => Str)
911              
912             Each argument is described in detail in: L<Paws::WAF::DeleteByteMatchSet>
913              
914             Returns: a L<Paws::WAF::DeleteByteMatchSetResponse> instance
915              
916             Permanently deletes a ByteMatchSet. You can't delete a C<ByteMatchSet>
917             if it's still used in any C<Rules> or if it still includes any
918             ByteMatchTuple objects (any filters).
919              
920             If you just want to remove a C<ByteMatchSet> from a C<Rule>, use
921             UpdateRule.
922              
923             To permanently delete a C<ByteMatchSet>, perform the following steps:
924              
925             =over
926              
927             =item 1.
928              
929             Update the C<ByteMatchSet> to remove filters, if any. For more
930             information, see UpdateByteMatchSet.
931              
932             =item 2.
933              
934             Use GetChangeToken to get the change token that you provide in the
935             C<ChangeToken> parameter of a C<DeleteByteMatchSet> request.
936              
937             =item 3.
938              
939             Submit a C<DeleteByteMatchSet> request.
940              
941             =back
942              
943              
944              
945             =head2 DeleteIPSet(ChangeToken => Str, IPSetId => Str)
946              
947             Each argument is described in detail in: L<Paws::WAF::DeleteIPSet>
948              
949             Returns: a L<Paws::WAF::DeleteIPSetResponse> instance
950              
951             Permanently deletes an IPSet. You can't delete an C<IPSet> if it's
952             still used in any C<Rules> or if it still includes any IP addresses.
953              
954             If you just want to remove an C<IPSet> from a C<Rule>, use UpdateRule.
955              
956             To permanently delete an C<IPSet> from AWS WAF, perform the following
957             steps:
958              
959             =over
960              
961             =item 1.
962              
963             Update the C<IPSet> to remove IP address ranges, if any. For more
964             information, see UpdateIPSet.
965              
966             =item 2.
967              
968             Use GetChangeToken to get the change token that you provide in the
969             C<ChangeToken> parameter of a C<DeleteIPSet> request.
970              
971             =item 3.
972              
973             Submit a C<DeleteIPSet> request.
974              
975             =back
976              
977              
978              
979             =head2 DeleteRateBasedRule(ChangeToken => Str, RuleId => Str)
980              
981             Each argument is described in detail in: L<Paws::WAF::DeleteRateBasedRule>
982              
983             Returns: a L<Paws::WAF::DeleteRateBasedRuleResponse> instance
984              
985             Permanently deletes a RateBasedRule. You can't delete a rule if it's
986             still used in any C<WebACL> objects or if it still includes any
987             predicates, such as C<ByteMatchSet> objects.
988              
989             If you just want to remove a rule from a C<WebACL>, use UpdateWebACL.
990              
991             To permanently delete a C<RateBasedRule> from AWS WAF, perform the
992             following steps:
993              
994             =over
995              
996             =item 1.
997              
998             Update the C<RateBasedRule> to remove predicates, if any. For more
999             information, see UpdateRateBasedRule.
1000              
1001             =item 2.
1002              
1003             Use GetChangeToken to get the change token that you provide in the
1004             C<ChangeToken> parameter of a C<DeleteRateBasedRule> request.
1005              
1006             =item 3.
1007              
1008             Submit a C<DeleteRateBasedRule> request.
1009              
1010             =back
1011              
1012              
1013              
1014             =head2 DeleteRule(ChangeToken => Str, RuleId => Str)
1015              
1016             Each argument is described in detail in: L<Paws::WAF::DeleteRule>
1017              
1018             Returns: a L<Paws::WAF::DeleteRuleResponse> instance
1019              
1020             Permanently deletes a Rule. You can't delete a C<Rule> if it's still
1021             used in any C<WebACL> objects or if it still includes any predicates,
1022             such as C<ByteMatchSet> objects.
1023              
1024             If you just want to remove a C<Rule> from a C<WebACL>, use
1025             UpdateWebACL.
1026              
1027             To permanently delete a C<Rule> from AWS WAF, perform the following
1028             steps:
1029              
1030             =over
1031              
1032             =item 1.
1033              
1034             Update the C<Rule> to remove predicates, if any. For more information,
1035             see UpdateRule.
1036              
1037             =item 2.
1038              
1039             Use GetChangeToken to get the change token that you provide in the
1040             C<ChangeToken> parameter of a C<DeleteRule> request.
1041              
1042             =item 3.
1043              
1044             Submit a C<DeleteRule> request.
1045              
1046             =back
1047              
1048              
1049              
1050             =head2 DeleteSizeConstraintSet(ChangeToken => Str, SizeConstraintSetId => Str)
1051              
1052             Each argument is described in detail in: L<Paws::WAF::DeleteSizeConstraintSet>
1053              
1054             Returns: a L<Paws::WAF::DeleteSizeConstraintSetResponse> instance
1055              
1056             Permanently deletes a SizeConstraintSet. You can't delete a
1057             C<SizeConstraintSet> if it's still used in any C<Rules> or if it still
1058             includes any SizeConstraint objects (any filters).
1059              
1060             If you just want to remove a C<SizeConstraintSet> from a C<Rule>, use
1061             UpdateRule.
1062              
1063             To permanently delete a C<SizeConstraintSet>, perform the following
1064             steps:
1065              
1066             =over
1067              
1068             =item 1.
1069              
1070             Update the C<SizeConstraintSet> to remove filters, if any. For more
1071             information, see UpdateSizeConstraintSet.
1072              
1073             =item 2.
1074              
1075             Use GetChangeToken to get the change token that you provide in the
1076             C<ChangeToken> parameter of a C<DeleteSizeConstraintSet> request.
1077              
1078             =item 3.
1079              
1080             Submit a C<DeleteSizeConstraintSet> request.
1081              
1082             =back
1083              
1084              
1085              
1086             =head2 DeleteSqlInjectionMatchSet(ChangeToken => Str, SqlInjectionMatchSetId => Str)
1087              
1088             Each argument is described in detail in: L<Paws::WAF::DeleteSqlInjectionMatchSet>
1089              
1090             Returns: a L<Paws::WAF::DeleteSqlInjectionMatchSetResponse> instance
1091              
1092             Permanently deletes a SqlInjectionMatchSet. You can't delete a
1093             C<SqlInjectionMatchSet> if it's still used in any C<Rules> or if it
1094             still contains any SqlInjectionMatchTuple objects.
1095              
1096             If you just want to remove a C<SqlInjectionMatchSet> from a C<Rule>,
1097             use UpdateRule.
1098              
1099             To permanently delete a C<SqlInjectionMatchSet> from AWS WAF, perform
1100             the following steps:
1101              
1102             =over
1103              
1104             =item 1.
1105              
1106             Update the C<SqlInjectionMatchSet> to remove filters, if any. For more
1107             information, see UpdateSqlInjectionMatchSet.
1108              
1109             =item 2.
1110              
1111             Use GetChangeToken to get the change token that you provide in the
1112             C<ChangeToken> parameter of a C<DeleteSqlInjectionMatchSet> request.
1113              
1114             =item 3.
1115              
1116             Submit a C<DeleteSqlInjectionMatchSet> request.
1117              
1118             =back
1119              
1120              
1121              
1122             =head2 DeleteWebACL(ChangeToken => Str, WebACLId => Str)
1123              
1124             Each argument is described in detail in: L<Paws::WAF::DeleteWebACL>
1125              
1126             Returns: a L<Paws::WAF::DeleteWebACLResponse> instance
1127              
1128             Permanently deletes a WebACL. You can't delete a C<WebACL> if it still
1129             contains any C<Rules>.
1130              
1131             To delete a C<WebACL>, perform the following steps:
1132              
1133             =over
1134              
1135             =item 1.
1136              
1137             Update the C<WebACL> to remove C<Rules>, if any. For more information,
1138             see UpdateWebACL.
1139              
1140             =item 2.
1141              
1142             Use GetChangeToken to get the change token that you provide in the
1143             C<ChangeToken> parameter of a C<DeleteWebACL> request.
1144              
1145             =item 3.
1146              
1147             Submit a C<DeleteWebACL> request.
1148              
1149             =back
1150              
1151              
1152              
1153             =head2 DeleteXssMatchSet(ChangeToken => Str, XssMatchSetId => Str)
1154              
1155             Each argument is described in detail in: L<Paws::WAF::DeleteXssMatchSet>
1156              
1157             Returns: a L<Paws::WAF::DeleteXssMatchSetResponse> instance
1158              
1159             Permanently deletes an XssMatchSet. You can't delete an C<XssMatchSet>
1160             if it's still used in any C<Rules> or if it still contains any
1161             XssMatchTuple objects.
1162              
1163             If you just want to remove an C<XssMatchSet> from a C<Rule>, use
1164             UpdateRule.
1165              
1166             To permanently delete an C<XssMatchSet> from AWS WAF, perform the
1167             following steps:
1168              
1169             =over
1170              
1171             =item 1.
1172              
1173             Update the C<XssMatchSet> to remove filters, if any. For more
1174             information, see UpdateXssMatchSet.
1175              
1176             =item 2.
1177              
1178             Use GetChangeToken to get the change token that you provide in the
1179             C<ChangeToken> parameter of a C<DeleteXssMatchSet> request.
1180              
1181             =item 3.
1182              
1183             Submit a C<DeleteXssMatchSet> request.
1184              
1185             =back
1186              
1187              
1188              
1189             =head2 GetByteMatchSet(ByteMatchSetId => Str)
1190              
1191             Each argument is described in detail in: L<Paws::WAF::GetByteMatchSet>
1192              
1193             Returns: a L<Paws::WAF::GetByteMatchSetResponse> instance
1194              
1195             Returns the ByteMatchSet specified by C<ByteMatchSetId>.
1196              
1197              
1198             =head2 GetChangeToken()
1199              
1200             Each argument is described in detail in: L<Paws::WAF::GetChangeToken>
1201              
1202             Returns: a L<Paws::WAF::GetChangeTokenResponse> instance
1203              
1204             When you want to create, update, or delete AWS WAF objects, get a
1205             change token and include the change token in the create, update, or
1206             delete request. Change tokens ensure that your application doesn't
1207             submit conflicting requests to AWS WAF.
1208              
1209             Each create, update, or delete request must use a unique change token.
1210             If your application submits a C<GetChangeToken> request and then
1211             submits a second C<GetChangeToken> request before submitting a create,
1212             update, or delete request, the second C<GetChangeToken> request returns
1213             the same value as the first C<GetChangeToken> request.
1214              
1215             When you use a change token in a create, update, or delete request, the
1216             status of the change token changes to C<PENDING>, which indicates that
1217             AWS WAF is propagating the change to all AWS WAF servers. Use
1218             C<GetChangeTokenStatus> to determine the status of your change token.
1219              
1220              
1221             =head2 GetChangeTokenStatus(ChangeToken => Str)
1222              
1223             Each argument is described in detail in: L<Paws::WAF::GetChangeTokenStatus>
1224              
1225             Returns: a L<Paws::WAF::GetChangeTokenStatusResponse> instance
1226              
1227             Returns the status of a C<ChangeToken> that you got by calling
1228             GetChangeToken. C<ChangeTokenStatus> is one of the following values:
1229              
1230             =over
1231              
1232             =item *
1233              
1234             C<PROVISIONED>: You requested the change token by calling
1235             C<GetChangeToken>, but you haven't used it yet in a call to create,
1236             update, or delete an AWS WAF object.
1237              
1238             =item *
1239              
1240             C<PENDING>: AWS WAF is propagating the create, update, or delete
1241             request to all AWS WAF servers.
1242              
1243             =item *
1244              
1245             C<IN_SYNC>: Propagation is complete.
1246              
1247             =back
1248              
1249              
1250              
1251             =head2 GetIPSet(IPSetId => Str)
1252              
1253             Each argument is described in detail in: L<Paws::WAF::GetIPSet>
1254              
1255             Returns: a L<Paws::WAF::GetIPSetResponse> instance
1256              
1257             Returns the IPSet that is specified by C<IPSetId>.
1258              
1259              
1260             =head2 GetRateBasedRule(RuleId => Str)
1261              
1262             Each argument is described in detail in: L<Paws::WAF::GetRateBasedRule>
1263              
1264             Returns: a L<Paws::WAF::GetRateBasedRuleResponse> instance
1265              
1266             Returns the RateBasedRule that is specified by the C<RuleId> that you
1267             included in the C<GetRateBasedRule> request.
1268              
1269              
1270             =head2 GetRateBasedRuleManagedKeys(RuleId => Str, [NextMarker => Str])
1271              
1272             Each argument is described in detail in: L<Paws::WAF::GetRateBasedRuleManagedKeys>
1273              
1274             Returns: a L<Paws::WAF::GetRateBasedRuleManagedKeysResponse> instance
1275              
1276             Returns an array of IP addresses currently being blocked by the
1277             RateBasedRule that is specified by the C<RuleId>. The maximum number of
1278             managed keys that will be blocked is 10,000. If more than 10,000
1279             addresses exceed the rate limit, the 10,000 addresses with the highest
1280             rates will be blocked.
1281              
1282              
1283             =head2 GetRule(RuleId => Str)
1284              
1285             Each argument is described in detail in: L<Paws::WAF::GetRule>
1286              
1287             Returns: a L<Paws::WAF::GetRuleResponse> instance
1288              
1289             Returns the Rule that is specified by the C<RuleId> that you included
1290             in the C<GetRule> request.
1291              
1292              
1293             =head2 GetSampledRequests(MaxItems => Int, RuleId => Str, TimeWindow => L<Paws::WAF::TimeWindow>, WebAclId => Str)
1294              
1295             Each argument is described in detail in: L<Paws::WAF::GetSampledRequests>
1296              
1297             Returns: a L<Paws::WAF::GetSampledRequestsResponse> instance
1298              
1299             Gets detailed information about a specified number of requests--a
1300             sample--that AWS WAF randomly selects from among the first 5,000
1301             requests that your AWS resource received during a time range that you
1302             choose. You can specify a sample size of up to 500 requests, and you
1303             can specify any time range in the previous three hours.
1304              
1305             C<GetSampledRequests> returns a time range, which is usually the time
1306             range that you specified. However, if your resource (such as a
1307             CloudFront distribution) received 5,000 requests before the specified
1308             time range elapsed, C<GetSampledRequests> returns an updated time
1309             range. This new time range indicates the actual period during which AWS
1310             WAF selected the requests in the sample.
1311              
1312              
1313             =head2 GetSizeConstraintSet(SizeConstraintSetId => Str)
1314              
1315             Each argument is described in detail in: L<Paws::WAF::GetSizeConstraintSet>
1316              
1317             Returns: a L<Paws::WAF::GetSizeConstraintSetResponse> instance
1318              
1319             Returns the SizeConstraintSet specified by C<SizeConstraintSetId>.
1320              
1321              
1322             =head2 GetSqlInjectionMatchSet(SqlInjectionMatchSetId => Str)
1323              
1324             Each argument is described in detail in: L<Paws::WAF::GetSqlInjectionMatchSet>
1325              
1326             Returns: a L<Paws::WAF::GetSqlInjectionMatchSetResponse> instance
1327              
1328             Returns the SqlInjectionMatchSet that is specified by
1329             C<SqlInjectionMatchSetId>.
1330              
1331              
1332             =head2 GetWebACL(WebACLId => Str)
1333              
1334             Each argument is described in detail in: L<Paws::WAF::GetWebACL>
1335              
1336             Returns: a L<Paws::WAF::GetWebACLResponse> instance
1337              
1338             Returns the WebACL that is specified by C<WebACLId>.
1339              
1340              
1341             =head2 GetXssMatchSet(XssMatchSetId => Str)
1342              
1343             Each argument is described in detail in: L<Paws::WAF::GetXssMatchSet>
1344              
1345             Returns: a L<Paws::WAF::GetXssMatchSetResponse> instance
1346              
1347             Returns the XssMatchSet that is specified by C<XssMatchSetId>.
1348              
1349              
1350             =head2 ListByteMatchSets([Limit => Int, NextMarker => Str])
1351              
1352             Each argument is described in detail in: L<Paws::WAF::ListByteMatchSets>
1353              
1354             Returns: a L<Paws::WAF::ListByteMatchSetsResponse> instance
1355              
1356             Returns an array of ByteMatchSetSummary objects.
1357              
1358              
1359             =head2 ListIPSets([Limit => Int, NextMarker => Str])
1360              
1361             Each argument is described in detail in: L<Paws::WAF::ListIPSets>
1362              
1363             Returns: a L<Paws::WAF::ListIPSetsResponse> instance
1364              
1365             Returns an array of IPSetSummary objects in the response.
1366              
1367              
1368             =head2 ListRateBasedRules([Limit => Int, NextMarker => Str])
1369              
1370             Each argument is described in detail in: L<Paws::WAF::ListRateBasedRules>
1371              
1372             Returns: a L<Paws::WAF::ListRateBasedRulesResponse> instance
1373              
1374             Returns an array of RuleSummary objects.
1375              
1376              
1377             =head2 ListRules([Limit => Int, NextMarker => Str])
1378              
1379             Each argument is described in detail in: L<Paws::WAF::ListRules>
1380              
1381             Returns: a L<Paws::WAF::ListRulesResponse> instance
1382              
1383             Returns an array of RuleSummary objects.
1384              
1385              
1386             =head2 ListSizeConstraintSets([Limit => Int, NextMarker => Str])
1387              
1388             Each argument is described in detail in: L<Paws::WAF::ListSizeConstraintSets>
1389              
1390             Returns: a L<Paws::WAF::ListSizeConstraintSetsResponse> instance
1391              
1392             Returns an array of SizeConstraintSetSummary objects.
1393              
1394              
1395             =head2 ListSqlInjectionMatchSets([Limit => Int, NextMarker => Str])
1396              
1397             Each argument is described in detail in: L<Paws::WAF::ListSqlInjectionMatchSets>
1398              
1399             Returns: a L<Paws::WAF::ListSqlInjectionMatchSetsResponse> instance
1400              
1401             Returns an array of SqlInjectionMatchSet objects.
1402              
1403              
1404             =head2 ListWebACLs([Limit => Int, NextMarker => Str])
1405              
1406             Each argument is described in detail in: L<Paws::WAF::ListWebACLs>
1407              
1408             Returns: a L<Paws::WAF::ListWebACLsResponse> instance
1409              
1410             Returns an array of WebACLSummary objects in the response.
1411              
1412              
1413             =head2 ListXssMatchSets([Limit => Int, NextMarker => Str])
1414              
1415             Each argument is described in detail in: L<Paws::WAF::ListXssMatchSets>
1416              
1417             Returns: a L<Paws::WAF::ListXssMatchSetsResponse> instance
1418              
1419             Returns an array of XssMatchSet objects.
1420              
1421              
1422             =head2 UpdateByteMatchSet(ByteMatchSetId => Str, ChangeToken => Str, Updates => ArrayRef[L<Paws::WAF::ByteMatchSetUpdate>])
1423              
1424             Each argument is described in detail in: L<Paws::WAF::UpdateByteMatchSet>
1425              
1426             Returns: a L<Paws::WAF::UpdateByteMatchSetResponse> instance
1427              
1428             Inserts or deletes ByteMatchTuple objects (filters) in a ByteMatchSet.
1429             For each C<ByteMatchTuple> object, you specify the following values:
1430              
1431             =over
1432              
1433             =item *
1434              
1435             Whether to insert or delete the object from the array. If you want to
1436             change a C<ByteMatchSetUpdate> object, you delete the existing object
1437             and add a new one.
1438              
1439             =item *
1440              
1441             The part of a web request that you want AWS WAF to inspect, such as a
1442             query string or the value of the C<User-Agent> header.
1443              
1444             =item *
1445              
1446             The bytes (typically a string that corresponds with ASCII characters)
1447             that you want AWS WAF to look for. For more information, including how
1448             you specify the values for the AWS WAF API and the AWS CLI or SDKs, see
1449             C<TargetString> in the ByteMatchTuple data type.
1450              
1451             =item *
1452              
1453             Where to look, such as at the beginning or the end of a query string.
1454              
1455             =item *
1456              
1457             Whether to perform any conversions on the request, such as converting
1458             it to lowercase, before inspecting it for the specified string.
1459              
1460             =back
1461              
1462             For example, you can add a C<ByteMatchSetUpdate> object that matches
1463             web requests in which C<User-Agent> headers contain the string
1464             C<BadBot>. You can then configure AWS WAF to block those requests.
1465              
1466             To create and configure a C<ByteMatchSet>, perform the following steps:
1467              
1468             =over
1469              
1470             =item 1.
1471              
1472             Create a C<ByteMatchSet.> For more information, see CreateByteMatchSet.
1473              
1474             =item 2.
1475              
1476             Use GetChangeToken to get the change token that you provide in the
1477             C<ChangeToken> parameter of an C<UpdateByteMatchSet> request.
1478              
1479             =item 3.
1480              
1481             Submit an C<UpdateByteMatchSet> request to specify the part of the
1482             request that you want AWS WAF to inspect (for example, the header or
1483             the URI) and the value that you want AWS WAF to watch for.
1484              
1485             =back
1486              
1487             For more information about how to use the AWS WAF API to allow or block
1488             HTTP requests, see the AWS WAF Developer Guide.
1489              
1490              
1491             =head2 UpdateIPSet(ChangeToken => Str, IPSetId => Str, Updates => ArrayRef[L<Paws::WAF::IPSetUpdate>])
1492              
1493             Each argument is described in detail in: L<Paws::WAF::UpdateIPSet>
1494              
1495             Returns: a L<Paws::WAF::UpdateIPSetResponse> instance
1496              
1497             Inserts or deletes IPSetDescriptor objects in an C<IPSet>. For each
1498             C<IPSetDescriptor> object, you specify the following values:
1499              
1500             =over
1501              
1502             =item *
1503              
1504             Whether to insert or delete the object from the array. If you want to
1505             change an C<IPSetDescriptor> object, you delete the existing object and
1506             add a new one.
1507              
1508             =item *
1509              
1510             The IP address version, C<IPv4> or C<IPv6>.
1511              
1512             =item *
1513              
1514             The IP address in CIDR notation, for example, C<192.0.2.0/24> (for the
1515             range of IP addresses from C<192.0.2.0> to C<192.0.2.255>) or
1516             C<192.0.2.44/32> (for the individual IP address C<192.0.2.44>).
1517              
1518             =back
1519              
1520             AWS WAF supports /8, /16, /24, and /32 IP address ranges for IPv4, and
1521             /24, /32, /48, /56, /64 and /128 for IPv6. For more information about
1522             CIDR notation, see the Wikipedia entry Classless Inter-Domain Routing.
1523              
1524             IPv6 addresses can be represented using any of the following formats:
1525              
1526             =over
1527              
1528             =item *
1529              
1530             1111:0000:0000:0000:0000:0000:0000:0111/128
1531              
1532             =item *
1533              
1534             1111:0:0:0:0:0:0:0111/128
1535              
1536             =item *
1537              
1538             1111::0111/128
1539              
1540             =item *
1541              
1542             1111::111/128
1543              
1544             =back
1545              
1546             You use an C<IPSet> to specify which web requests you want to allow or
1547             block based on the IP addresses that the requests originated from. For
1548             example, if you're receiving a lot of requests from one or a small
1549             number of IP addresses and you want to block the requests, you can
1550             create an C<IPSet> that specifies those IP addresses, and then
1551             configure AWS WAF to block the requests.
1552              
1553             To create and configure an C<IPSet>, perform the following steps:
1554              
1555             =over
1556              
1557             =item 1.
1558              
1559             Submit a CreateIPSet request.
1560              
1561             =item 2.
1562              
1563             Use GetChangeToken to get the change token that you provide in the
1564             C<ChangeToken> parameter of an UpdateIPSet request.
1565              
1566             =item 3.
1567              
1568             Submit an C<UpdateIPSet> request to specify the IP addresses that you
1569             want AWS WAF to watch for.
1570              
1571             =back
1572              
1573             When you update an C<IPSet>, you specify the IP addresses that you want
1574             to add and/or the IP addresses that you want to delete. If you want to
1575             change an IP address, you delete the existing IP address and add the
1576             new one.
1577              
1578             For more information about how to use the AWS WAF API to allow or block
1579             HTTP requests, see the AWS WAF Developer Guide.
1580              
1581              
1582             =head2 UpdateRateBasedRule(ChangeToken => Str, RateLimit => Int, RuleId => Str, Updates => ArrayRef[L<Paws::WAF::RuleUpdate>])
1583              
1584             Each argument is described in detail in: L<Paws::WAF::UpdateRateBasedRule>
1585              
1586             Returns: a L<Paws::WAF::UpdateRateBasedRuleResponse> instance
1587              
1588             Inserts or deletes Predicate objects in a rule and updates the
1589             C<RateLimit> in the rule.
1590              
1591             Each C<Predicate> object identifies a predicate, such as a ByteMatchSet
1592             or an IPSet, that specifies the web requests that you want to block or
1593             count. The C<RateLimit> specifies the number of requests every five
1594             minutes that triggers the rule.
1595              
1596             If you add more than one predicate to a C<RateBasedRule>, a request
1597             must match all the predicates and exceed the C<RateLimit> to be counted
1598             or blocked. For example, suppose you add the following to a
1599             C<RateBasedRule>:
1600              
1601             =over
1602              
1603             =item *
1604              
1605             An C<IPSet> that matches the IP address C<192.0.2.44/32>
1606              
1607             =item *
1608              
1609             A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
1610              
1611             =back
1612              
1613             Further, you specify a C<RateLimit> of 15,000.
1614              
1615             You then add the C<RateBasedRule> to a C<WebACL> and specify that you
1616             want to block requests that satisfy the rule. For a request to be
1617             blocked, it must come from the IP address 192.0.2.44 I<and> the
1618             C<User-Agent> header in the request must contain the value C<BadBot>.
1619             Further, requests that match these two conditions much be received at a
1620             rate of more than 15,000 every five minutes. If the rate drops below
1621             this limit, AWS WAF no longer blocks the requests.
1622              
1623             As a second example, suppose you want to limit requests to a particular
1624             page on your site. To do this, you could add the following to a
1625             C<RateBasedRule>:
1626              
1627             =over
1628              
1629             =item *
1630              
1631             A C<ByteMatchSet> with C<FieldToMatch> of C<URI>
1632              
1633             =item *
1634              
1635             A C<PositionalConstraint> of C<STARTS_WITH>
1636              
1637             =item *
1638              
1639             A C<TargetString> of C<login>
1640              
1641             =back
1642              
1643             Further, you specify a C<RateLimit> of 15,000.
1644              
1645             By adding this C<RateBasedRule> to a C<WebACL>, you could limit
1646             requests to your login page without affecting the rest of your site.
1647              
1648              
1649             =head2 UpdateRule(ChangeToken => Str, RuleId => Str, Updates => ArrayRef[L<Paws::WAF::RuleUpdate>])
1650              
1651             Each argument is described in detail in: L<Paws::WAF::UpdateRule>
1652              
1653             Returns: a L<Paws::WAF::UpdateRuleResponse> instance
1654              
1655             Inserts or deletes Predicate objects in a C<Rule>. Each C<Predicate>
1656             object identifies a predicate, such as a ByteMatchSet or an IPSet, that
1657             specifies the web requests that you want to allow, block, or count. If
1658             you add more than one predicate to a C<Rule>, a request must match all
1659             of the specifications to be allowed, blocked, or counted. For example,
1660             suppose you add the following to a C<Rule>:
1661              
1662             =over
1663              
1664             =item *
1665              
1666             A C<ByteMatchSet> that matches the value C<BadBot> in the C<User-Agent>
1667             header
1668              
1669             =item *
1670              
1671             An C<IPSet> that matches the IP address C<192.0.2.44>
1672              
1673             =back
1674              
1675             You then add the C<Rule> to a C<WebACL> and specify that you want to
1676             block requests that satisfy the C<Rule>. For a request to be blocked,
1677             the C<User-Agent> header in the request must contain the value
1678             C<BadBot> I<and> the request must originate from the IP address
1679             192.0.2.44.
1680              
1681             To create and configure a C<Rule>, perform the following steps:
1682              
1683             =over
1684              
1685             =item 1.
1686              
1687             Create and update the predicates that you want to include in the
1688             C<Rule>.
1689              
1690             =item 2.
1691              
1692             Create the C<Rule>. See CreateRule.
1693              
1694             =item 3.
1695              
1696             Use C<GetChangeToken> to get the change token that you provide in the
1697             C<ChangeToken> parameter of an UpdateRule request.
1698              
1699             =item 4.
1700              
1701             Submit an C<UpdateRule> request to add predicates to the C<Rule>.
1702              
1703             =item 5.
1704              
1705             Create and update a C<WebACL> that contains the C<Rule>. See
1706             CreateWebACL.
1707              
1708             =back
1709              
1710             If you want to replace one C<ByteMatchSet> or C<IPSet> with another,
1711             you delete the existing one and add the new one.
1712              
1713             For more information about how to use the AWS WAF API to allow or block
1714             HTTP requests, see the AWS WAF Developer Guide.
1715              
1716              
1717             =head2 UpdateSizeConstraintSet(ChangeToken => Str, SizeConstraintSetId => Str, Updates => ArrayRef[L<Paws::WAF::SizeConstraintSetUpdate>])
1718              
1719             Each argument is described in detail in: L<Paws::WAF::UpdateSizeConstraintSet>
1720              
1721             Returns: a L<Paws::WAF::UpdateSizeConstraintSetResponse> instance
1722              
1723             Inserts or deletes SizeConstraint objects (filters) in a
1724             SizeConstraintSet. For each C<SizeConstraint> object, you specify the
1725             following values:
1726              
1727             =over
1728              
1729             =item *
1730              
1731             Whether to insert or delete the object from the array. If you want to
1732             change a C<SizeConstraintSetUpdate> object, you delete the existing
1733             object and add a new one.
1734              
1735             =item *
1736              
1737             The part of a web request that you want AWS WAF to evaluate, such as
1738             the length of a query string or the length of the C<User-Agent> header.
1739              
1740             =item *
1741              
1742             Whether to perform any transformations on the request, such as
1743             converting it to lowercase, before checking its length. Note that
1744             transformations of the request body are not supported because the AWS
1745             resource forwards only the first C<8192> bytes of your request to AWS
1746             WAF.
1747              
1748             =item *
1749              
1750             A C<ComparisonOperator> used for evaluating the selected part of the
1751             request against the specified C<Size>, such as equals, greater than,
1752             less than, and so on.
1753              
1754             =item *
1755              
1756             The length, in bytes, that you want AWS WAF to watch for in selected
1757             part of the request. The length is computed after applying the
1758             transformation.
1759              
1760             =back
1761              
1762             For example, you can add a C<SizeConstraintSetUpdate> object that
1763             matches web requests in which the length of the C<User-Agent> header is
1764             greater than 100 bytes. You can then configure AWS WAF to block those
1765             requests.
1766              
1767             To create and configure a C<SizeConstraintSet>, perform the following
1768             steps:
1769              
1770             =over
1771              
1772             =item 1.
1773              
1774             Create a C<SizeConstraintSet.> For more information, see
1775             CreateSizeConstraintSet.
1776              
1777             =item 2.
1778              
1779             Use GetChangeToken to get the change token that you provide in the
1780             C<ChangeToken> parameter of an C<UpdateSizeConstraintSet> request.
1781              
1782             =item 3.
1783              
1784             Submit an C<UpdateSizeConstraintSet> request to specify the part of the
1785             request that you want AWS WAF to inspect (for example, the header or
1786             the URI) and the value that you want AWS WAF to watch for.
1787              
1788             =back
1789              
1790             For more information about how to use the AWS WAF API to allow or block
1791             HTTP requests, see the AWS WAF Developer Guide.
1792              
1793              
1794             =head2 UpdateSqlInjectionMatchSet(ChangeToken => Str, SqlInjectionMatchSetId => Str, Updates => ArrayRef[L<Paws::WAF::SqlInjectionMatchSetUpdate>])
1795              
1796             Each argument is described in detail in: L<Paws::WAF::UpdateSqlInjectionMatchSet>
1797              
1798             Returns: a L<Paws::WAF::UpdateSqlInjectionMatchSetResponse> instance
1799              
1800             Inserts or deletes SqlInjectionMatchTuple objects (filters) in a
1801             SqlInjectionMatchSet. For each C<SqlInjectionMatchTuple> object, you
1802             specify the following values:
1803              
1804             =over
1805              
1806             =item *
1807              
1808             C<Action>: Whether to insert the object into or delete the object from
1809             the array. To change a C<SqlInjectionMatchTuple>, you delete the
1810             existing object and add a new one.
1811              
1812             =item *
1813              
1814             C<FieldToMatch>: The part of web requests that you want AWS WAF to
1815             inspect and, if you want AWS WAF to inspect a header, the name of the
1816             header.
1817              
1818             =item *
1819              
1820             C<TextTransformation>: Which text transformation, if any, to perform on
1821             the web request before inspecting the request for snippets of malicious
1822             SQL code.
1823              
1824             =back
1825              
1826             You use C<SqlInjectionMatchSet> objects to specify which CloudFront
1827             requests you want to allow, block, or count. For example, if you're
1828             receiving requests that contain snippets of SQL code in the query
1829             string and you want to block the requests, you can create a
1830             C<SqlInjectionMatchSet> with the applicable settings, and then
1831             configure AWS WAF to block the requests.
1832              
1833             To create and configure a C<SqlInjectionMatchSet>, perform the
1834             following steps:
1835              
1836             =over
1837              
1838             =item 1.
1839              
1840             Submit a CreateSqlInjectionMatchSet request.
1841              
1842             =item 2.
1843              
1844             Use GetChangeToken to get the change token that you provide in the
1845             C<ChangeToken> parameter of an UpdateIPSet request.
1846              
1847             =item 3.
1848              
1849             Submit an C<UpdateSqlInjectionMatchSet> request to specify the parts of
1850             web requests that you want AWS WAF to inspect for snippets of SQL code.
1851              
1852             =back
1853              
1854             For more information about how to use the AWS WAF API to allow or block
1855             HTTP requests, see the AWS WAF Developer Guide.
1856              
1857              
1858             =head2 UpdateWebACL(ChangeToken => Str, WebACLId => Str, [DefaultAction => L<Paws::WAF::WafAction>, Updates => ArrayRef[L<Paws::WAF::WebACLUpdate>]])
1859              
1860             Each argument is described in detail in: L<Paws::WAF::UpdateWebACL>
1861              
1862             Returns: a L<Paws::WAF::UpdateWebACLResponse> instance
1863              
1864             Inserts or deletes ActivatedRule objects in a C<WebACL>. Each C<Rule>
1865             identifies web requests that you want to allow, block, or count. When
1866             you update a C<WebACL>, you specify the following values:
1867              
1868             =over
1869              
1870             =item *
1871              
1872             A default action for the C<WebACL>, either C<ALLOW> or C<BLOCK>. AWS
1873             WAF performs the default action if a request doesn't match the criteria
1874             in any of the C<Rules> in a C<WebACL>.
1875              
1876             =item *
1877              
1878             The C<Rules> that you want to add and/or delete. If you want to replace
1879             one C<Rule> with another, you delete the existing C<Rule> and add the
1880             new one.
1881              
1882             =item *
1883              
1884             For each C<Rule>, whether you want AWS WAF to allow requests, block
1885             requests, or count requests that match the conditions in the C<Rule>.
1886              
1887             =item *
1888              
1889             The order in which you want AWS WAF to evaluate the C<Rules> in a
1890             C<WebACL>. If you add more than one C<Rule> to a C<WebACL>, AWS WAF
1891             evaluates each request against the C<Rules> in order based on the value
1892             of C<Priority>. (The C<Rule> that has the lowest value for C<Priority>
1893             is evaluated first.) When a web request matches all of the predicates
1894             (such as C<ByteMatchSets> and C<IPSets>) in a C<Rule>, AWS WAF
1895             immediately takes the corresponding action, allow or block, and doesn't
1896             evaluate the request against the remaining C<Rules> in the C<WebACL>,
1897             if any.
1898              
1899             =back
1900              
1901             To create and configure a C<WebACL>, perform the following steps:
1902              
1903             =over
1904              
1905             =item 1.
1906              
1907             Create and update the predicates that you want to include in C<Rules>.
1908             For more information, see CreateByteMatchSet, UpdateByteMatchSet,
1909             CreateIPSet, UpdateIPSet, CreateSqlInjectionMatchSet, and
1910             UpdateSqlInjectionMatchSet.
1911              
1912             =item 2.
1913              
1914             Create and update the C<Rules> that you want to include in the
1915             C<WebACL>. For more information, see CreateRule and UpdateRule.
1916              
1917             =item 3.
1918              
1919             Create a C<WebACL>. See CreateWebACL.
1920              
1921             =item 4.
1922              
1923             Use C<GetChangeToken> to get the change token that you provide in the
1924             C<ChangeToken> parameter of an UpdateWebACL request.
1925              
1926             =item 5.
1927              
1928             Submit an C<UpdateWebACL> request to specify the C<Rules> that you want
1929             to include in the C<WebACL>, to specify the default action, and to
1930             associate the C<WebACL> with a CloudFront distribution.
1931              
1932             =back
1933              
1934             Be aware that if you try to add a RATE_BASED rule to a web ACL without
1935             setting the rule type when first creating the rule, the UpdateWebACL
1936             request will fail because the request tries to add a REGULAR rule (the
1937             default rule type) with the specified ID, which does not exist.
1938              
1939             For more information about how to use the AWS WAF API to allow or block
1940             HTTP requests, see the AWS WAF Developer Guide.
1941              
1942              
1943             =head2 UpdateXssMatchSet(ChangeToken => Str, Updates => ArrayRef[L<Paws::WAF::XssMatchSetUpdate>], XssMatchSetId => Str)
1944              
1945             Each argument is described in detail in: L<Paws::WAF::UpdateXssMatchSet>
1946              
1947             Returns: a L<Paws::WAF::UpdateXssMatchSetResponse> instance
1948              
1949             Inserts or deletes XssMatchTuple objects (filters) in an XssMatchSet.
1950             For each C<XssMatchTuple> object, you specify the following values:
1951              
1952             =over
1953              
1954             =item *
1955              
1956             C<Action>: Whether to insert the object into or delete the object from
1957             the array. To change a C<XssMatchTuple>, you delete the existing object
1958             and add a new one.
1959              
1960             =item *
1961              
1962             C<FieldToMatch>: The part of web requests that you want AWS WAF to
1963             inspect and, if you want AWS WAF to inspect a header, the name of the
1964             header.
1965              
1966             =item *
1967              
1968             C<TextTransformation>: Which text transformation, if any, to perform on
1969             the web request before inspecting the request for cross-site scripting
1970             attacks.
1971              
1972             =back
1973              
1974             You use C<XssMatchSet> objects to specify which CloudFront requests you
1975             want to allow, block, or count. For example, if you're receiving
1976             requests that contain cross-site scripting attacks in the request body
1977             and you want to block the requests, you can create an C<XssMatchSet>
1978             with the applicable settings, and then configure AWS WAF to block the
1979             requests.
1980              
1981             To create and configure an C<XssMatchSet>, perform the following steps:
1982              
1983             =over
1984              
1985             =item 1.
1986              
1987             Submit a CreateXssMatchSet request.
1988              
1989             =item 2.
1990              
1991             Use GetChangeToken to get the change token that you provide in the
1992             C<ChangeToken> parameter of an UpdateIPSet request.
1993              
1994             =item 3.
1995              
1996             Submit an C<UpdateXssMatchSet> request to specify the parts of web
1997             requests that you want AWS WAF to inspect for cross-site scripting
1998             attacks.
1999              
2000             =back
2001              
2002             For more information about how to use the AWS WAF API to allow or block
2003             HTTP requests, see the AWS WAF Developer Guide.
2004              
2005              
2006              
2007              
2008             =head1 PAGINATORS
2009              
2010             Paginator methods are helpers that repetively call methods that return partial results
2011              
2012             =head2 ListAllByteMatchSets(sub { },[Limit => Int, NextMarker => Str])
2013              
2014             =head2 ListAllByteMatchSets([Limit => Int, NextMarker => Str])
2015              
2016              
2017             If passed a sub as first parameter, it will call the sub for each element found in :
2018              
2019             - ByteMatchSets, passing the object as the first parameter, and the string 'ByteMatchSets' as the second parameter
2020              
2021             If not, it will return a a L<Paws::WAF::ListByteMatchSetsResponse> 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.
2022              
2023              
2024             =head2 ListAllIPSets(sub { },[Limit => Int, NextMarker => Str])
2025              
2026             =head2 ListAllIPSets([Limit => Int, NextMarker => Str])
2027              
2028              
2029             If passed a sub as first parameter, it will call the sub for each element found in :
2030              
2031             - IPSets, passing the object as the first parameter, and the string 'IPSets' as the second parameter
2032              
2033             If not, it will return a a L<Paws::WAF::ListIPSetsResponse> 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.
2034              
2035              
2036             =head2 ListAllRules(sub { },[Limit => Int, NextMarker => Str])
2037              
2038             =head2 ListAllRules([Limit => Int, NextMarker => Str])
2039              
2040              
2041             If passed a sub as first parameter, it will call the sub for each element found in :
2042              
2043             - Rules, passing the object as the first parameter, and the string 'Rules' as the second parameter
2044              
2045             If not, it will return a a L<Paws::WAF::ListRulesResponse> 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.
2046              
2047              
2048             =head2 ListAllSizeConstraintSets(sub { },[Limit => Int, NextMarker => Str])
2049              
2050             =head2 ListAllSizeConstraintSets([Limit => Int, NextMarker => Str])
2051              
2052              
2053             If passed a sub as first parameter, it will call the sub for each element found in :
2054              
2055             - SizeConstraintSets, passing the object as the first parameter, and the string 'SizeConstraintSets' as the second parameter
2056              
2057             If not, it will return a a L<Paws::WAF::ListSizeConstraintSetsResponse> 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.
2058              
2059              
2060             =head2 ListAllSqlInjectionMatchSets(sub { },[Limit => Int, NextMarker => Str])
2061              
2062             =head2 ListAllSqlInjectionMatchSets([Limit => Int, NextMarker => Str])
2063              
2064              
2065             If passed a sub as first parameter, it will call the sub for each element found in :
2066              
2067             - SqlInjectionMatchSets, passing the object as the first parameter, and the string 'SqlInjectionMatchSets' as the second parameter
2068              
2069             If not, it will return a a L<Paws::WAF::ListSqlInjectionMatchSetsResponse> 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.
2070              
2071              
2072             =head2 ListAllWebACLs(sub { },[Limit => Int, NextMarker => Str])
2073              
2074             =head2 ListAllWebACLs([Limit => Int, NextMarker => Str])
2075              
2076              
2077             If passed a sub as first parameter, it will call the sub for each element found in :
2078              
2079             - WebACLs, passing the object as the first parameter, and the string 'WebACLs' as the second parameter
2080              
2081             If not, it will return a a L<Paws::WAF::ListWebACLsResponse> 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.
2082              
2083              
2084             =head2 ListAllXssMatchSets(sub { },[Limit => Int, NextMarker => Str])
2085              
2086             =head2 ListAllXssMatchSets([Limit => Int, NextMarker => Str])
2087              
2088              
2089             If passed a sub as first parameter, it will call the sub for each element found in :
2090              
2091             - XssMatchSets, passing the object as the first parameter, and the string 'XssMatchSets' as the second parameter
2092              
2093             If not, it will return a a L<Paws::WAF::ListXssMatchSetsResponse> 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.
2094              
2095              
2096              
2097              
2098              
2099             =head1 SEE ALSO
2100              
2101             This service class forms part of L<Paws>
2102              
2103             =head1 BUGS and CONTRIBUTIONS
2104              
2105             The source code is located here: https://github.com/pplu/aws-sdk-perl
2106              
2107             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
2108              
2109             =cut
2110