blib/lib/Paws/WAFRegional.pm untested

filter: Statementstmt 0.0% 0 / 258 Branchbran n/a Conditioncond n/a MC/DCmcdc n/a Subroutinesub 0.0% 0 / 88 Podpod 0.0% 0 / 87 totaltotal 0.0% 0 / 433 CC 1 SCAR 6.9
CC
1
Cov
0%
service
2.0
signing_name
2.0
version
2.0
CRAP 2.0
1 package Paws::WAFRegional;
2 use Moose;
3 sub service { 'waf-regional' }
4 sub signing_name { 'waf-regional' }
5 sub version { '2016-11-28' }
6 sub target_prefix { 'AWSWAF_Regional_20161128' }
7 sub json_version { "1.1" }
8 has max_attempts => (is => 'ro', isa => 'Int', default => 5);
9 has retry => (is => 'ro', isa => 'HashRef', default => sub {
10 { base => 'rand', type => 'exponential', growth_factor => 2 }
11 });
12 has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
13 ] });
14  
15 with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller';
16  
17
18 sub AssociateWebACL {
19 my $self = shift;
20 my $call_object = $self->new_with_coercions('Paws::WAFRegional::AssociateWebACL', @_);
21 return $self->caller->do_call($self, $call_object);
22 }
23 sub CreateByteMatchSet {
24 my $self = shift;
25 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateByteMatchSet', @_);
26 return $self->caller->do_call($self, $call_object);
27 }
28 sub CreateGeoMatchSet {
29 my $self = shift;
30 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateGeoMatchSet', @_);
31 return $self->caller->do_call($self, $call_object);
32 }
33 sub CreateIPSet {
34 my $self = shift;
35 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateIPSet', @_);
36 return $self->caller->do_call($self, $call_object);
37 }
38 sub CreateRateBasedRule {
39 my $self = shift;
40 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateRateBasedRule', @_);
41 return $self->caller->do_call($self, $call_object);
42 }
43 sub CreateRegexMatchSet {
44 my $self = shift;
45 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateRegexMatchSet', @_);
46 return $self->caller->do_call($self, $call_object);
47 }
48 sub CreateRegexPatternSet {
49 my $self = shift;
50 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateRegexPatternSet', @_);
51 return $self->caller->do_call($self, $call_object);
52 }
53 sub CreateRule {
54 my $self = shift;
55 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateRule', @_);
56 return $self->caller->do_call($self, $call_object);
57 }
58 sub CreateRuleGroup {
59 my $self = shift;
60 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateRuleGroup', @_);
61 return $self->caller->do_call($self, $call_object);
62 }
63 sub CreateSizeConstraintSet {
64 my $self = shift;
65 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateSizeConstraintSet', @_);
66 return $self->caller->do_call($self, $call_object);
67 }
68 sub CreateSqlInjectionMatchSet {
69 my $self = shift;
70 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateSqlInjectionMatchSet', @_);
71 return $self->caller->do_call($self, $call_object);
72 }
73 sub CreateWebACL {
74 my $self = shift;
75 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateWebACL', @_);
76 return $self->caller->do_call($self, $call_object);
77 }
78 sub CreateWebACLMigrationStack {
79 my $self = shift;
80 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateWebACLMigrationStack', @_);
81 return $self->caller->do_call($self, $call_object);
82 }
83 sub CreateXssMatchSet {
84 my $self = shift;
85 my $call_object = $self->new_with_coercions('Paws::WAFRegional::CreateXssMatchSet', @_);
86 return $self->caller->do_call($self, $call_object);
87 }
88 sub DeleteByteMatchSet {
89 my $self = shift;
90 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteByteMatchSet', @_);
91 return $self->caller->do_call($self, $call_object);
92 }
93 sub DeleteGeoMatchSet {
94 my $self = shift;
95 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteGeoMatchSet', @_);
96 return $self->caller->do_call($self, $call_object);
97 }
98 sub DeleteIPSet {
99 my $self = shift;
100 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteIPSet', @_);
101 return $self->caller->do_call($self, $call_object);
102 }
103 sub DeleteLoggingConfiguration {
104 my $self = shift;
105 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteLoggingConfiguration', @_);
106 return $self->caller->do_call($self, $call_object);
107 }
108 sub DeletePermissionPolicy {
109 my $self = shift;
110 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeletePermissionPolicy', @_);
111 return $self->caller->do_call($self, $call_object);
112 }
113 sub DeleteRateBasedRule {
114 my $self = shift;
115 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteRateBasedRule', @_);
116 return $self->caller->do_call($self, $call_object);
117 }
118 sub DeleteRegexMatchSet {
119 my $self = shift;
120 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteRegexMatchSet', @_);
121 return $self->caller->do_call($self, $call_object);
122 }
123 sub DeleteRegexPatternSet {
124 my $self = shift;
125 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteRegexPatternSet', @_);
126 return $self->caller->do_call($self, $call_object);
127 }
128 sub DeleteRule {
129 my $self = shift;
130 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteRule', @_);
131 return $self->caller->do_call($self, $call_object);
132 }
133 sub DeleteRuleGroup {
134 my $self = shift;
135 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteRuleGroup', @_);
136 return $self->caller->do_call($self, $call_object);
137 }
138 sub DeleteSizeConstraintSet {
139 my $self = shift;
140 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteSizeConstraintSet', @_);
141 return $self->caller->do_call($self, $call_object);
142 }
143 sub DeleteSqlInjectionMatchSet {
144 my $self = shift;
145 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteSqlInjectionMatchSet', @_);
146 return $self->caller->do_call($self, $call_object);
147 }
148 sub DeleteWebACL {
149 my $self = shift;
150 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteWebACL', @_);
151 return $self->caller->do_call($self, $call_object);
152 }
153 sub DeleteXssMatchSet {
154 my $self = shift;
155 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DeleteXssMatchSet', @_);
156 return $self->caller->do_call($self, $call_object);
157 }
158 sub DisassociateWebACL {
159 my $self = shift;
160 my $call_object = $self->new_with_coercions('Paws::WAFRegional::DisassociateWebACL', @_);
161 return $self->caller->do_call($self, $call_object);
162 }
163 sub GetByteMatchSet {
164 my $self = shift;
165 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetByteMatchSet', @_);
166 return $self->caller->do_call($self, $call_object);
167 }
168 sub GetChangeToken {
169 my $self = shift;
170 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetChangeToken', @_);
171 return $self->caller->do_call($self, $call_object);
172 }
173 sub GetChangeTokenStatus {
174 my $self = shift;
175 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetChangeTokenStatus', @_);
176 return $self->caller->do_call($self, $call_object);
177 }
178 sub GetGeoMatchSet {
179 my $self = shift;
180 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetGeoMatchSet', @_);
181 return $self->caller->do_call($self, $call_object);
182 }
183 sub GetIPSet {
184 my $self = shift;
185 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetIPSet', @_);
186 return $self->caller->do_call($self, $call_object);
187 }
188 sub GetLoggingConfiguration {
189 my $self = shift;
190 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetLoggingConfiguration', @_);
191 return $self->caller->do_call($self, $call_object);
192 }
193 sub GetPermissionPolicy {
194 my $self = shift;
195 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetPermissionPolicy', @_);
196 return $self->caller->do_call($self, $call_object);
197 }
198 sub GetRateBasedRule {
199 my $self = shift;
200 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRateBasedRule', @_);
201 return $self->caller->do_call($self, $call_object);
202 }
203 sub GetRateBasedRuleManagedKeys {
204 my $self = shift;
205 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRateBasedRuleManagedKeys', @_);
206 return $self->caller->do_call($self, $call_object);
207 }
208 sub GetRegexMatchSet {
209 my $self = shift;
210 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRegexMatchSet', @_);
211 return $self->caller->do_call($self, $call_object);
212 }
213 sub GetRegexPatternSet {
214 my $self = shift;
215 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRegexPatternSet', @_);
216 return $self->caller->do_call($self, $call_object);
217 }
218 sub GetRule {
219 my $self = shift;
220 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRule', @_);
221 return $self->caller->do_call($self, $call_object);
222 }
223 sub GetRuleGroup {
224 my $self = shift;
225 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetRuleGroup', @_);
226 return $self->caller->do_call($self, $call_object);
227 }
228 sub GetSampledRequests {
229 my $self = shift;
230 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetSampledRequests', @_);
231 return $self->caller->do_call($self, $call_object);
232 }
233 sub GetSizeConstraintSet {
234 my $self = shift;
235 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetSizeConstraintSet', @_);
236 return $self->caller->do_call($self, $call_object);
237 }
238 sub GetSqlInjectionMatchSet {
239 my $self = shift;
240 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetSqlInjectionMatchSet', @_);
241 return $self->caller->do_call($self, $call_object);
242 }
243 sub GetWebACL {
244 my $self = shift;
245 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetWebACL', @_);
246 return $self->caller->do_call($self, $call_object);
247 }
248 sub GetWebACLForResource {
249 my $self = shift;
250 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetWebACLForResource', @_);
251 return $self->caller->do_call($self, $call_object);
252 }
253 sub GetXssMatchSet {
254 my $self = shift;
255 my $call_object = $self->new_with_coercions('Paws::WAFRegional::GetXssMatchSet', @_);
256 return $self->caller->do_call($self, $call_object);
257 }
258 sub ListActivatedRulesInRuleGroup {
259 my $self = shift;
260 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListActivatedRulesInRuleGroup', @_);
261 return $self->caller->do_call($self, $call_object);
262 }
263 sub ListByteMatchSets {
264 my $self = shift;
265 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListByteMatchSets', @_);
266 return $self->caller->do_call($self, $call_object);
267 }
268 sub ListGeoMatchSets {
269 my $self = shift;
270 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListGeoMatchSets', @_);
271 return $self->caller->do_call($self, $call_object);
272 }
273 sub ListIPSets {
274 my $self = shift;
275 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListIPSets', @_);
276 return $self->caller->do_call($self, $call_object);
277 }
278 sub ListLoggingConfigurations {
279 my $self = shift;
280 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListLoggingConfigurations', @_);
281 return $self->caller->do_call($self, $call_object);
282 }
283 sub ListRateBasedRules {
284 my $self = shift;
285 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListRateBasedRules', @_);
286 return $self->caller->do_call($self, $call_object);
287 }
288 sub ListRegexMatchSets {
289 my $self = shift;
290 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListRegexMatchSets', @_);
291 return $self->caller->do_call($self, $call_object);
292 }
293 sub ListRegexPatternSets {
294 my $self = shift;
295 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListRegexPatternSets', @_);
296 return $self->caller->do_call($self, $call_object);
297 }
298 sub ListResourcesForWebACL {
299 my $self = shift;
300 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListResourcesForWebACL', @_);
301 return $self->caller->do_call($self, $call_object);
302 }
303 sub ListRuleGroups {
304 my $self = shift;
305 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListRuleGroups', @_);
306 return $self->caller->do_call($self, $call_object);
307 }
308 sub ListRules {
309 my $self = shift;
310 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListRules', @_);
311 return $self->caller->do_call($self, $call_object);
312 }
313 sub ListSizeConstraintSets {
314 my $self = shift;
315 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListSizeConstraintSets', @_);
316 return $self->caller->do_call($self, $call_object);
317 }
318 sub ListSqlInjectionMatchSets {
319 my $self = shift;
320 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListSqlInjectionMatchSets', @_);
321 return $self->caller->do_call($self, $call_object);
322 }
323 sub ListSubscribedRuleGroups {
324 my $self = shift;
325 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListSubscribedRuleGroups', @_);
326 return $self->caller->do_call($self, $call_object);
327 }
328 sub ListTagsForResource {
329 my $self = shift;
330 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListTagsForResource', @_);
331 return $self->caller->do_call($self, $call_object);
332 }
333 sub ListWebACLs {
334 my $self = shift;
335 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListWebACLs', @_);
336 return $self->caller->do_call($self, $call_object);
337 }
338 sub ListXssMatchSets {
339 my $self = shift;
340 my $call_object = $self->new_with_coercions('Paws::WAFRegional::ListXssMatchSets', @_);
341 return $self->caller->do_call($self, $call_object);
342 }
343 sub PutLoggingConfiguration {
344 my $self = shift;
345 my $call_object = $self->new_with_coercions('Paws::WAFRegional::PutLoggingConfiguration', @_);
346 return $self->caller->do_call($self, $call_object);
347 }
348 sub PutPermissionPolicy {
349 my $self = shift;
350 my $call_object = $self->new_with_coercions('Paws::WAFRegional::PutPermissionPolicy', @_);
351 return $self->caller->do_call($self, $call_object);
352 }
353 sub TagResource {
354 my $self = shift;
355 my $call_object = $self->new_with_coercions('Paws::WAFRegional::TagResource', @_);
356 return $self->caller->do_call($self, $call_object);
357 }
358 sub UntagResource {
359 my $self = shift;
360 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UntagResource', @_);
361 return $self->caller->do_call($self, $call_object);
362 }
363 sub UpdateByteMatchSet {
364 my $self = shift;
365 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateByteMatchSet', @_);
366 return $self->caller->do_call($self, $call_object);
367 }
368 sub UpdateGeoMatchSet {
369 my $self = shift;
370 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateGeoMatchSet', @_);
371 return $self->caller->do_call($self, $call_object);
372 }
373 sub UpdateIPSet {
374 my $self = shift;
375 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateIPSet', @_);
376 return $self->caller->do_call($self, $call_object);
377 }
378 sub UpdateRateBasedRule {
379 my $self = shift;
380 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateRateBasedRule', @_);
381 return $self->caller->do_call($self, $call_object);
382 }
383 sub UpdateRegexMatchSet {
384 my $self = shift;
385 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateRegexMatchSet', @_);
386 return $self->caller->do_call($self, $call_object);
387 }
388 sub UpdateRegexPatternSet {
389 my $self = shift;
390 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateRegexPatternSet', @_);
391 return $self->caller->do_call($self, $call_object);
392 }
393 sub UpdateRule {
394 my $self = shift;
395 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateRule', @_);
396 return $self->caller->do_call($self, $call_object);
397 }
398 sub UpdateRuleGroup {
399 my $self = shift;
400 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateRuleGroup', @_);
401 return $self->caller->do_call($self, $call_object);
402 }
403 sub UpdateSizeConstraintSet {
404 my $self = shift;
405 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateSizeConstraintSet', @_);
406 return $self->caller->do_call($self, $call_object);
407 }
408 sub UpdateSqlInjectionMatchSet {
409 my $self = shift;
410 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateSqlInjectionMatchSet', @_);
411 return $self->caller->do_call($self, $call_object);
412 }
413 sub UpdateWebACL {
414 my $self = shift;
415 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateWebACL', @_);
416 return $self->caller->do_call($self, $call_object);
417 }
418 sub UpdateXssMatchSet {
419 my $self = shift;
420 my $call_object = $self->new_with_coercions('Paws::WAFRegional::UpdateXssMatchSet', @_);
421 return $self->caller->do_call($self, $call_object);
422 }
423
424  
425  
426 sub operations { qw/AssociateWebACL CreateByteMatchSet CreateGeoMatchSet CreateIPSet CreateRateBasedRule CreateRegexMatchSet CreateRegexPatternSet CreateRule CreateRuleGroup CreateSizeConstraintSet CreateSqlInjectionMatchSet CreateWebACL CreateWebACLMigrationStack CreateXssMatchSet DeleteByteMatchSet DeleteGeoMatchSet DeleteIPSet DeleteLoggingConfiguration DeletePermissionPolicy DeleteRateBasedRule DeleteRegexMatchSet DeleteRegexPatternSet DeleteRule DeleteRuleGroup DeleteSizeConstraintSet DeleteSqlInjectionMatchSet DeleteWebACL DeleteXssMatchSet DisassociateWebACL GetByteMatchSet GetChangeToken GetChangeTokenStatus GetGeoMatchSet GetIPSet GetLoggingConfiguration GetPermissionPolicy GetRateBasedRule GetRateBasedRuleManagedKeys GetRegexMatchSet GetRegexPatternSet GetRule GetRuleGroup GetSampledRequests GetSizeConstraintSet GetSqlInjectionMatchSet GetWebACL GetWebACLForResource GetXssMatchSet ListActivatedRulesInRuleGroup ListByteMatchSets ListGeoMatchSets ListIPSets ListLoggingConfigurations ListRateBasedRules ListRegexMatchSets ListRegexPatternSets ListResourcesForWebACL ListRuleGroups ListRules ListSizeConstraintSets ListSqlInjectionMatchSets ListSubscribedRuleGroups ListTagsForResource ListWebACLs ListXssMatchSets PutLoggingConfiguration PutPermissionPolicy TagResource UntagResource UpdateByteMatchSet UpdateGeoMatchSet UpdateIPSet UpdateRateBasedRule UpdateRegexMatchSet UpdateRegexPatternSet UpdateRule UpdateRuleGroup UpdateSizeConstraintSet UpdateSqlInjectionMatchSet UpdateWebACL UpdateXssMatchSet / }
427  
428 1;
429  
430 ### main pod documentation begin ###
431  
432 =head1 NAME
433  
434 Paws::WAFRegional - Perl Interface to AWS AWS WAF Regional
435  
436 =head1 SYNOPSIS
437  
438 use Paws;
439  
440 my $obj = Paws->service('WAFRegional');
441 my $res = $obj->Method(
442 Arg1 => $val1,
443 Arg2 => [ 'V1', 'V2' ],
444 # if Arg3 is an object, the HashRef will be used as arguments to the constructor
445 # of the arguments type
446 Arg3 => { Att1 => 'Val1' },
447 # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
448 # the constructor of the arguments type
449 Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
450 );
451  
452 =head1 DESCRIPTION
453  
454 This is B<AWS WAF Classic Regional> documentation. For more
455 information, see AWS WAF Classic
456 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
457 in the developer guide.
458  
459 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
460 AWS WAF Developer Guide
461 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
462 With the latest version, AWS WAF has a single set of endpoints for
463 regional and global use.
464  
465 This is the I<AWS WAF Regional Classic API Reference> for using AWS WAF
466 Classic with the AWS resources, Elastic Load Balancing (ELB)
467 Application Load Balancers and API Gateway APIs. The AWS WAF Classic
468 actions and data types listed in the reference are available for
469 protecting Elastic Load Balancing (ELB) Application Load Balancers and
470 API Gateway APIs. You can use these actions and data types by means of
471 the endpoints listed in AWS Regions and Endpoints
472 (https://docs.aws.amazon.com/general/latest/gr/rande.html#waf_region).
473 This guide is for developers who need detailed information about the
474 AWS WAF Classic API actions, data types, and errors. For detailed
475 information about AWS WAF Classic features and an overview of how to
476 use the AWS WAF Classic API, see the AWS WAF Classic
477 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
478 in the developer guide.
479  
480 For the AWS API documentation, see L<https://docs.aws.amazon.com/goto/WebAPI/waf-regional-2016-11-28>
481  
482  
483 =head1 METHODS
484  
485 =head2 AssociateWebACL
486  
487 =over
488  
489 =item ResourceArn => Str
490  
491 =item WebACLId => Str
492  
493  
494 =back
495  
496 Each argument is described in detail in: L<Paws::WAFRegional::AssociateWebACL>
497  
498 Returns: a L<Paws::WAFRegional::AssociateWebACLResponse> instance
499  
500 This is B<AWS WAF Classic Regional> documentation. For more
501 information, see AWS WAF Classic
502 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
503 in the developer guide.
504  
505 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
506 AWS WAF Developer Guide
507 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
508 With the latest version, AWS WAF has a single set of endpoints for
509 regional and global use.
510  
511 Associates a web ACL with a resource, either an application load
512 balancer or Amazon API Gateway stage.
513  
514  
515 =head2 CreateByteMatchSet
516  
517 =over
518  
519 =item ChangeToken => Str
520  
521 =item Name => Str
522  
523  
524 =back
525  
526 Each argument is described in detail in: L<Paws::WAFRegional::CreateByteMatchSet>
527  
528 Returns: a L<Paws::WAFRegional::CreateByteMatchSetResponse> instance
529  
530 This is B<AWS WAF Classic> documentation. For more information, see AWS
531 WAF Classic
532 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
533 in the developer guide.
534  
535 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
536 AWS WAF Developer Guide
537 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
538 With the latest version, AWS WAF has a single set of endpoints for
539 regional and global use.
540  
541 Creates a C<ByteMatchSet>. You then use UpdateByteMatchSet to identify
542 the part of a web request that you want AWS WAF to inspect, such as the
543 values of the C<User-Agent> header or the query string. For example,
544 you can create a C<ByteMatchSet> that matches any requests with
545 C<User-Agent> headers that contain the string C<BadBot>. You can then
546 configure AWS WAF to reject those requests.
547  
548 To create and configure a C<ByteMatchSet>, perform the following steps:
549  
550 =over
551  
552 =item 1.
553  
554 Use GetChangeToken to get the change token that you provide in the
555 C<ChangeToken> parameter of a C<CreateByteMatchSet> request.
556  
557 =item 2.
558  
559 Submit a C<CreateByteMatchSet> request.
560  
561 =item 3.
562  
563 Use C<GetChangeToken> to get the change token that you provide in the
564 C<ChangeToken> parameter of an C<UpdateByteMatchSet> request.
565  
566 =item 4.
567  
568 Submit an UpdateByteMatchSet request to specify the part of the request
569 that you want AWS WAF to inspect (for example, the header or the URI)
570 and the value that you want AWS WAF to watch for.
571  
572 =back
573  
574 For more information about how to use the AWS WAF API to allow or block
575 HTTP requests, see the AWS WAF Developer Guide
576 (https://docs.aws.amazon.com/waf/latest/developerguide/).
577  
578  
579 =head2 CreateGeoMatchSet
580  
581 =over
582  
583 =item ChangeToken => Str
584  
585 =item Name => Str
586  
587  
588 =back
589  
590 Each argument is described in detail in: L<Paws::WAFRegional::CreateGeoMatchSet>
591  
592 Returns: a L<Paws::WAFRegional::CreateGeoMatchSetResponse> instance
593  
594 This is B<AWS WAF Classic> documentation. For more information, see AWS
595 WAF Classic
596 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
597 in the developer guide.
598  
599 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
600 AWS WAF Developer Guide
601 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
602 With the latest version, AWS WAF has a single set of endpoints for
603 regional and global use.
604  
605 Creates an GeoMatchSet, which you use to specify which web requests you
606 want to allow or block based on the country that the requests originate
607 from. For example, if you're receiving a lot of requests from one or
608 more countries and you want to block the requests, you can create an
609 C<GeoMatchSet> that contains those countries and then configure AWS WAF
610 to block the requests.
611  
612 To create and configure a C<GeoMatchSet>, perform the following steps:
613  
614 =over
615  
616 =item 1.
617  
618 Use GetChangeToken to get the change token that you provide in the
619 C<ChangeToken> parameter of a C<CreateGeoMatchSet> request.
620  
621 =item 2.
622  
623 Submit a C<CreateGeoMatchSet> request.
624  
625 =item 3.
626  
627 Use C<GetChangeToken> to get the change token that you provide in the
628 C<ChangeToken> parameter of an UpdateGeoMatchSet request.
629  
630 =item 4.
631  
632 Submit an C<UpdateGeoMatchSetSet> request to specify the countries that
633 you want AWS WAF to watch for.
634  
635 =back
636  
637 For more information about how to use the AWS WAF API to allow or block
638 HTTP requests, see the AWS WAF Developer Guide
639 (https://docs.aws.amazon.com/waf/latest/developerguide/).
640  
641  
642 =head2 CreateIPSet
643  
644 =over
645  
646 =item ChangeToken => Str
647  
648 =item Name => Str
649  
650  
651 =back
652  
653 Each argument is described in detail in: L<Paws::WAFRegional::CreateIPSet>
654  
655 Returns: a L<Paws::WAFRegional::CreateIPSetResponse> instance
656  
657 This is B<AWS WAF Classic> documentation. For more information, see AWS
658 WAF Classic
659 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
660 in the developer guide.
661  
662 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
663 AWS WAF Developer Guide
664 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
665 With the latest version, AWS WAF has a single set of endpoints for
666 regional and global use.
667  
668 Creates an IPSet, which you use to specify which web requests that you
669 want to allow or block based on the IP addresses that the requests
670 originate from. For example, if you're receiving a lot of requests from
671 one or more individual IP addresses or one or more ranges of IP
672 addresses and you want to block the requests, you can create an
673 C<IPSet> that contains those IP addresses and then configure AWS WAF to
674 block the requests.
675  
676 To create and configure an C<IPSet>, perform the following steps:
677  
678 =over
679  
680 =item 1.
681  
682 Use GetChangeToken to get the change token that you provide in the
683 C<ChangeToken> parameter of a C<CreateIPSet> request.
684  
685 =item 2.
686  
687 Submit a C<CreateIPSet> request.
688  
689 =item 3.
690  
691 Use C<GetChangeToken> to get the change token that you provide in the
692 C<ChangeToken> parameter of an UpdateIPSet request.
693  
694 =item 4.
695  
696 Submit an C<UpdateIPSet> request to specify the IP addresses that you
697 want AWS WAF to watch for.
698  
699 =back
700  
701 For more information about how to use the AWS WAF API to allow or block
702 HTTP requests, see the AWS WAF Developer Guide
703 (https://docs.aws.amazon.com/waf/latest/developerguide/).
704  
705  
706 =head2 CreateRateBasedRule
707  
708 =over
709  
710 =item ChangeToken => Str
711  
712 =item MetricName => Str
713  
714 =item Name => Str
715  
716 =item RateKey => Str
717  
718 =item RateLimit => Int
719  
720 =item [Tags => ArrayRef[L<Paws::WAFRegional::Tag>]]
721  
722  
723 =back
724  
725 Each argument is described in detail in: L<Paws::WAFRegional::CreateRateBasedRule>
726  
727 Returns: a L<Paws::WAFRegional::CreateRateBasedRuleResponse> instance
728  
729 This is B<AWS WAF Classic> documentation. For more information, see AWS
730 WAF Classic
731 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
732 in the developer guide.
733  
734 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
735 AWS WAF Developer Guide
736 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
737 With the latest version, AWS WAF has a single set of endpoints for
738 regional and global use.
739  
740 Creates a RateBasedRule. The C<RateBasedRule> contains a C<RateLimit>,
741 which specifies the maximum number of requests that AWS WAF allows from
742 a specified IP address in a five-minute period. The C<RateBasedRule>
743 also contains the C<IPSet> objects, C<ByteMatchSet> objects, and other
744 predicates that identify the requests that you want to count or block
745 if these requests exceed the C<RateLimit>.
746  
747 If you add more than one predicate to a C<RateBasedRule>, a request not
748 only must exceed the C<RateLimit>, but it also must match all the
749 conditions to be counted or blocked. For example, suppose you add the
750 following to a C<RateBasedRule>:
751  
752 =over
753  
754 =item *
755  
756 An C<IPSet> that matches the IP address C<192.0.2.44/32>
757  
758 =item *
759  
760 A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
761  
762 =back
763  
764 Further, you specify a C<RateLimit> of 1,000.
765  
766 You then add the C<RateBasedRule> to a C<WebACL> and specify that you
767 want to block requests that meet the conditions in the rule. For a
768 request to be blocked, it must come from the IP address 192.0.2.44
769 I<and> the C<User-Agent> header in the request must contain the value
770 C<BadBot>. Further, requests that match these two conditions must be
771 received at a rate of more than 1,000 requests every five minutes. If
772 both conditions are met and the rate is exceeded, AWS WAF blocks the
773 requests. If the rate drops below 1,000 for a five-minute period, AWS
774 WAF no longer blocks the requests.
775  
776 As a second example, suppose you want to limit requests to a particular
777 page on your site. To do this, you could add the following to a
778 C<RateBasedRule>:
779  
780 =over
781  
782 =item *
783  
784 A C<ByteMatchSet> with C<FieldToMatch> of C<URI>
785  
786 =item *
787  
788 A C<PositionalConstraint> of C<STARTS_WITH>
789  
790 =item *
791  
792 A C<TargetString> of C<login>
793  
794 =back
795  
796 Further, you specify a C<RateLimit> of 1,000.
797  
798 By adding this C<RateBasedRule> to a C<WebACL>, you could limit
799 requests to your login page without affecting the rest of your site.
800  
801 To create and configure a C<RateBasedRule>, perform the following
802 steps:
803  
804 =over
805  
806 =item 1.
807  
808 Create and update the predicates that you want to include in the rule.
809 For more information, see CreateByteMatchSet, CreateIPSet, and
810 CreateSqlInjectionMatchSet.
811  
812 =item 2.
813  
814 Use GetChangeToken to get the change token that you provide in the
815 C<ChangeToken> parameter of a C<CreateRule> request.
816  
817 =item 3.
818  
819 Submit a C<CreateRateBasedRule> request.
820  
821 =item 4.
822  
823 Use C<GetChangeToken> to get the change token that you provide in the
824 C<ChangeToken> parameter of an UpdateRule request.
825  
826 =item 5.
827  
828 Submit an C<UpdateRateBasedRule> request to specify the predicates that
829 you want to include in the rule.
830  
831 =item 6.
832  
833 Create and update a C<WebACL> that contains the C<RateBasedRule>. For
834 more information, see CreateWebACL.
835  
836 =back
837  
838 For more information about how to use the AWS WAF API to allow or block
839 HTTP requests, see the AWS WAF Developer Guide
840 (https://docs.aws.amazon.com/waf/latest/developerguide/).
841  
842  
843 =head2 CreateRegexMatchSet
844  
845 =over
846  
847 =item ChangeToken => Str
848  
849 =item Name => Str
850  
851  
852 =back
853  
854 Each argument is described in detail in: L<Paws::WAFRegional::CreateRegexMatchSet>
855  
856 Returns: a L<Paws::WAFRegional::CreateRegexMatchSetResponse> instance
857  
858 This is B<AWS WAF Classic> documentation. For more information, see AWS
859 WAF Classic
860 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
861 in the developer guide.
862  
863 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
864 AWS WAF Developer Guide
865 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
866 With the latest version, AWS WAF has a single set of endpoints for
867 regional and global use.
868  
869 Creates a RegexMatchSet. You then use UpdateRegexMatchSet to identify
870 the part of a web request that you want AWS WAF to inspect, such as the
871 values of the C<User-Agent> header or the query string. For example,
872 you can create a C<RegexMatchSet> that contains a C<RegexMatchTuple>
873 that looks for any requests with C<User-Agent> headers that match a
874 C<RegexPatternSet> with pattern C<B[a@]dB[o0]t>. You can then configure
875 AWS WAF to reject those requests.
876  
877 To create and configure a C<RegexMatchSet>, perform the following
878 steps:
879  
880 =over
881  
882 =item 1.
883  
884 Use GetChangeToken to get the change token that you provide in the
885 C<ChangeToken> parameter of a C<CreateRegexMatchSet> request.
886  
887 =item 2.
888  
889 Submit a C<CreateRegexMatchSet> request.
890  
891 =item 3.
892  
893 Use C<GetChangeToken> to get the change token that you provide in the
894 C<ChangeToken> parameter of an C<UpdateRegexMatchSet> request.
895  
896 =item 4.
897  
898 Submit an UpdateRegexMatchSet request to specify the part of the
899 request that you want AWS WAF to inspect (for example, the header or
900 the URI) and the value, using a C<RegexPatternSet>, that you want AWS
901 WAF to watch for.
902  
903 =back
904  
905 For more information about how to use the AWS WAF API to allow or block
906 HTTP requests, see the AWS WAF Developer Guide
907 (https://docs.aws.amazon.com/waf/latest/developerguide/).
908  
909  
910 =head2 CreateRegexPatternSet
911  
912 =over
913  
914 =item ChangeToken => Str
915  
916 =item Name => Str
917  
918  
919 =back
920  
921 Each argument is described in detail in: L<Paws::WAFRegional::CreateRegexPatternSet>
922  
923 Returns: a L<Paws::WAFRegional::CreateRegexPatternSetResponse> instance
924  
925 This is B<AWS WAF Classic> documentation. For more information, see AWS
926 WAF Classic
927 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
928 in the developer guide.
929  
930 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
931 AWS WAF Developer Guide
932 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
933 With the latest version, AWS WAF has a single set of endpoints for
934 regional and global use.
935  
936 Creates a C<RegexPatternSet>. You then use UpdateRegexPatternSet to
937 specify the regular expression (regex) pattern that you want AWS WAF to
938 search for, such as C<B[a@]dB[o0]t>. You can then configure AWS WAF to
939 reject those requests.
940  
941 To create and configure a C<RegexPatternSet>, perform the following
942 steps:
943  
944 =over
945  
946 =item 1.
947  
948 Use GetChangeToken to get the change token that you provide in the
949 C<ChangeToken> parameter of a C<CreateRegexPatternSet> request.
950  
951 =item 2.
952  
953 Submit a C<CreateRegexPatternSet> request.
954  
955 =item 3.
956  
957 Use C<GetChangeToken> to get the change token that you provide in the
958 C<ChangeToken> parameter of an C<UpdateRegexPatternSet> request.
959  
960 =item 4.
961  
962 Submit an UpdateRegexPatternSet request to specify the string that you
963 want AWS WAF to watch for.
964  
965 =back
966  
967 For more information about how to use the AWS WAF API to allow or block
968 HTTP requests, see the AWS WAF Developer Guide
969 (https://docs.aws.amazon.com/waf/latest/developerguide/).
970  
971  
972 =head2 CreateRule
973  
974 =over
975  
976 =item ChangeToken => Str
977  
978 =item MetricName => Str
979  
980 =item Name => Str
981  
982 =item [Tags => ArrayRef[L<Paws::WAFRegional::Tag>]]
983  
984  
985 =back
986  
987 Each argument is described in detail in: L<Paws::WAFRegional::CreateRule>
988  
989 Returns: a L<Paws::WAFRegional::CreateRuleResponse> instance
990  
991 This is B<AWS WAF Classic> documentation. For more information, see AWS
992 WAF Classic
993 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
994 in the developer guide.
995  
996 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
997 AWS WAF Developer Guide
998 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
999 With the latest version, AWS WAF has a single set of endpoints for
1000 regional and global use.
1001  
1002 Creates a C<Rule>, which contains the C<IPSet> objects, C<ByteMatchSet>
1003 objects, and other predicates that identify the requests that you want
1004 to block. If you add more than one predicate to a C<Rule>, a request
1005 must match all of the specifications to be allowed or blocked. For
1006 example, suppose that you add the following to a C<Rule>:
1007  
1008 =over
1009  
1010 =item *
1011  
1012 An C<IPSet> that matches the IP address C<192.0.2.44/32>
1013  
1014 =item *
1015  
1016 A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
1017  
1018 =back
1019  
1020 You then add the C<Rule> to a C<WebACL> and specify that you want to
1021 blocks requests that satisfy the C<Rule>. For a request to be blocked,
1022 it must come from the IP address 192.0.2.44 I<and> the C<User-Agent>
1023 header in the request must contain the value C<BadBot>.
1024  
1025 To create and configure a C<Rule>, perform the following steps:
1026  
1027 =over
1028  
1029 =item 1.
1030  
1031 Create and update the predicates that you want to include in the
1032 C<Rule>. For more information, see CreateByteMatchSet, CreateIPSet, and
1033 CreateSqlInjectionMatchSet.
1034  
1035 =item 2.
1036  
1037 Use GetChangeToken to get the change token that you provide in the
1038 C<ChangeToken> parameter of a C<CreateRule> request.
1039  
1040 =item 3.
1041  
1042 Submit a C<CreateRule> request.
1043  
1044 =item 4.
1045  
1046 Use C<GetChangeToken> to get the change token that you provide in the
1047 C<ChangeToken> parameter of an UpdateRule request.
1048  
1049 =item 5.
1050  
1051 Submit an C<UpdateRule> request to specify the predicates that you want
1052 to include in the C<Rule>.
1053  
1054 =item 6.
1055  
1056 Create and update a C<WebACL> that contains the C<Rule>. For more
1057 information, see CreateWebACL.
1058  
1059 =back
1060  
1061 For more information about how to use the AWS WAF API to allow or block
1062 HTTP requests, see the AWS WAF Developer Guide
1063 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1064  
1065  
1066 =head2 CreateRuleGroup
1067  
1068 =over
1069  
1070 =item ChangeToken => Str
1071  
1072 =item MetricName => Str
1073  
1074 =item Name => Str
1075  
1076 =item [Tags => ArrayRef[L<Paws::WAFRegional::Tag>]]
1077  
1078  
1079 =back
1080  
1081 Each argument is described in detail in: L<Paws::WAFRegional::CreateRuleGroup>
1082  
1083 Returns: a L<Paws::WAFRegional::CreateRuleGroupResponse> instance
1084  
1085 This is B<AWS WAF Classic> documentation. For more information, see AWS
1086 WAF Classic
1087 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1088 in the developer guide.
1089  
1090 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1091 AWS WAF Developer Guide
1092 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1093 With the latest version, AWS WAF has a single set of endpoints for
1094 regional and global use.
1095  
1096 Creates a C<RuleGroup>. A rule group is a collection of predefined
1097 rules that you add to a web ACL. You use UpdateRuleGroup to add rules
1098 to the rule group.
1099  
1100 Rule groups are subject to the following limits:
1101  
1102 =over
1103  
1104 =item *
1105  
1106 Three rule groups per account. You can request an increase to this
1107 limit by contacting customer support.
1108  
1109 =item *
1110  
1111 One rule group per web ACL.
1112  
1113 =item *
1114  
1115 Ten rules per rule group.
1116  
1117 =back
1118  
1119 For more information about how to use the AWS WAF API to allow or block
1120 HTTP requests, see the AWS WAF Developer Guide
1121 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1122  
1123  
1124 =head2 CreateSizeConstraintSet
1125  
1126 =over
1127  
1128 =item ChangeToken => Str
1129  
1130 =item Name => Str
1131  
1132  
1133 =back
1134  
1135 Each argument is described in detail in: L<Paws::WAFRegional::CreateSizeConstraintSet>
1136  
1137 Returns: a L<Paws::WAFRegional::CreateSizeConstraintSetResponse> instance
1138  
1139 This is B<AWS WAF Classic> documentation. For more information, see AWS
1140 WAF Classic
1141 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1142 in the developer guide.
1143  
1144 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1145 AWS WAF Developer Guide
1146 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1147 With the latest version, AWS WAF has a single set of endpoints for
1148 regional and global use.
1149  
1150 Creates a C<SizeConstraintSet>. You then use UpdateSizeConstraintSet to
1151 identify the part of a web request that you want AWS WAF to check for
1152 length, such as the length of the C<User-Agent> header or the length of
1153 the query string. For example, you can create a C<SizeConstraintSet>
1154 that matches any requests that have a query string that is longer than
1155 100 bytes. You can then configure AWS WAF to reject those requests.
1156  
1157 To create and configure a C<SizeConstraintSet>, perform the following
1158 steps:
1159  
1160 =over
1161  
1162 =item 1.
1163  
1164 Use GetChangeToken to get the change token that you provide in the
1165 C<ChangeToken> parameter of a C<CreateSizeConstraintSet> request.
1166  
1167 =item 2.
1168  
1169 Submit a C<CreateSizeConstraintSet> request.
1170  
1171 =item 3.
1172  
1173 Use C<GetChangeToken> to get the change token that you provide in the
1174 C<ChangeToken> parameter of an C<UpdateSizeConstraintSet> request.
1175  
1176 =item 4.
1177  
1178 Submit an UpdateSizeConstraintSet request to specify the part of the
1179 request that you want AWS WAF to inspect (for example, the header or
1180 the URI) and the value that you want AWS WAF to watch for.
1181  
1182 =back
1183  
1184 For more information about how to use the AWS WAF API to allow or block
1185 HTTP requests, see the AWS WAF Developer Guide
1186 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1187  
1188  
1189 =head2 CreateSqlInjectionMatchSet
1190  
1191 =over
1192  
1193 =item ChangeToken => Str
1194  
1195 =item Name => Str
1196  
1197  
1198 =back
1199  
1200 Each argument is described in detail in: L<Paws::WAFRegional::CreateSqlInjectionMatchSet>
1201  
1202 Returns: a L<Paws::WAFRegional::CreateSqlInjectionMatchSetResponse> instance
1203  
1204 This is B<AWS WAF Classic> documentation. For more information, see AWS
1205 WAF Classic
1206 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1207 in the developer guide.
1208  
1209 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1210 AWS WAF Developer Guide
1211 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1212 With the latest version, AWS WAF has a single set of endpoints for
1213 regional and global use.
1214  
1215 Creates a SqlInjectionMatchSet, which you use to allow, block, or count
1216 requests that contain snippets of SQL code in a specified part of web
1217 requests. AWS WAF searches for character sequences that are likely to
1218 be malicious strings.
1219  
1220 To create and configure a C<SqlInjectionMatchSet>, perform the
1221 following steps:
1222  
1223 =over
1224  
1225 =item 1.
1226  
1227 Use GetChangeToken to get the change token that you provide in the
1228 C<ChangeToken> parameter of a C<CreateSqlInjectionMatchSet> request.
1229  
1230 =item 2.
1231  
1232 Submit a C<CreateSqlInjectionMatchSet> request.
1233  
1234 =item 3.
1235  
1236 Use C<GetChangeToken> to get the change token that you provide in the
1237 C<ChangeToken> parameter of an UpdateSqlInjectionMatchSet request.
1238  
1239 =item 4.
1240  
1241 Submit an UpdateSqlInjectionMatchSet request to specify the parts of
1242 web requests in which you want to allow, block, or count malicious SQL
1243 code.
1244  
1245 =back
1246  
1247 For more information about how to use the AWS WAF API to allow or block
1248 HTTP requests, see the AWS WAF Developer Guide
1249 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1250  
1251  
1252 =head2 CreateWebACL
1253  
1254 =over
1255  
1256 =item ChangeToken => Str
1257  
1258 =item DefaultAction => L<Paws::WAFRegional::WafAction>
1259  
1260 =item MetricName => Str
1261  
1262 =item Name => Str
1263  
1264 =item [Tags => ArrayRef[L<Paws::WAFRegional::Tag>]]
1265  
1266  
1267 =back
1268  
1269 Each argument is described in detail in: L<Paws::WAFRegional::CreateWebACL>
1270  
1271 Returns: a L<Paws::WAFRegional::CreateWebACLResponse> instance
1272  
1273 This is B<AWS WAF Classic> documentation. For more information, see AWS
1274 WAF Classic
1275 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1276 in the developer guide.
1277  
1278 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1279 AWS WAF Developer Guide
1280 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1281 With the latest version, AWS WAF has a single set of endpoints for
1282 regional and global use.
1283  
1284 Creates a C<WebACL>, which contains the C<Rules> that identify the
1285 CloudFront web requests that you want to allow, block, or count. AWS
1286 WAF evaluates C<Rules> in order based on the value of C<Priority> for
1287 each C<Rule>.
1288  
1289 You also specify a default action, either C<ALLOW> or C<BLOCK>. If a
1290 web request doesn't match any of the C<Rules> in a C<WebACL>, AWS WAF
1291 responds to the request with the default action.
1292  
1293 To create and configure a C<WebACL>, perform the following steps:
1294  
1295 =over
1296  
1297 =item 1.
1298  
1299 Create and update the C<ByteMatchSet> objects and other predicates that
1300 you want to include in C<Rules>. For more information, see
1301 CreateByteMatchSet, UpdateByteMatchSet, CreateIPSet, UpdateIPSet,
1302 CreateSqlInjectionMatchSet, and UpdateSqlInjectionMatchSet.
1303  
1304 =item 2.
1305  
1306 Create and update the C<Rules> that you want to include in the
1307 C<WebACL>. For more information, see CreateRule and UpdateRule.
1308  
1309 =item 3.
1310  
1311 Use GetChangeToken to get the change token that you provide in the
1312 C<ChangeToken> parameter of a C<CreateWebACL> request.
1313  
1314 =item 4.
1315  
1316 Submit a C<CreateWebACL> request.
1317  
1318 =item 5.
1319  
1320 Use C<GetChangeToken> to get the change token that you provide in the
1321 C<ChangeToken> parameter of an UpdateWebACL request.
1322  
1323 =item 6.
1324  
1325 Submit an UpdateWebACL request to specify the C<Rules> that you want to
1326 include in the C<WebACL>, to specify the default action, and to
1327 associate the C<WebACL> with a CloudFront distribution.
1328  
1329 =back
1330  
1331 For more information about how to use the AWS WAF API, see the AWS WAF
1332 Developer Guide
1333 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1334  
1335  
1336 =head2 CreateWebACLMigrationStack
1337  
1338 =over
1339  
1340 =item IgnoreUnsupportedType => Bool
1341  
1342 =item S3BucketName => Str
1343  
1344 =item WebACLId => Str
1345  
1346  
1347 =back
1348  
1349 Each argument is described in detail in: L<Paws::WAFRegional::CreateWebACLMigrationStack>
1350  
1351 Returns: a L<Paws::WAFRegional::CreateWebACLMigrationStackResponse> instance
1352  
1353 Creates an AWS CloudFormation WAFV2 template for the specified web ACL
1354 in the specified Amazon S3 bucket. Then, in CloudFormation, you create
1355 a stack from the template, to create the web ACL and its resources in
1356 AWS WAFV2. Use this to migrate your AWS WAF Classic web ACL to the
1357 latest version of AWS WAF.
1358  
1359 This is part of a larger migration procedure for web ACLs from AWS WAF
1360 Classic to the latest version of AWS WAF. For the full procedure,
1361 including caveats and manual steps to complete the migration and switch
1362 over to the new web ACL, see Migrating your AWS WAF Classic resources
1363 to AWS WAF
1364 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-migrating-from-classic.html)
1365 in the AWS WAF Developer Guide
1366 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1367  
1368  
1369 =head2 CreateXssMatchSet
1370  
1371 =over
1372  
1373 =item ChangeToken => Str
1374  
1375 =item Name => Str
1376  
1377  
1378 =back
1379  
1380 Each argument is described in detail in: L<Paws::WAFRegional::CreateXssMatchSet>
1381  
1382 Returns: a L<Paws::WAFRegional::CreateXssMatchSetResponse> instance
1383  
1384 This is B<AWS WAF Classic> documentation. For more information, see AWS
1385 WAF Classic
1386 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1387 in the developer guide.
1388  
1389 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1390 AWS WAF Developer Guide
1391 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1392 With the latest version, AWS WAF has a single set of endpoints for
1393 regional and global use.
1394  
1395 Creates an XssMatchSet, which you use to allow, block, or count
1396 requests that contain cross-site scripting attacks in the specified
1397 part of web requests. AWS WAF searches for character sequences that are
1398 likely to be malicious strings.
1399  
1400 To create and configure an C<XssMatchSet>, perform the following steps:
1401  
1402 =over
1403  
1404 =item 1.
1405  
1406 Use GetChangeToken to get the change token that you provide in the
1407 C<ChangeToken> parameter of a C<CreateXssMatchSet> request.
1408  
1409 =item 2.
1410  
1411 Submit a C<CreateXssMatchSet> request.
1412  
1413 =item 3.
1414  
1415 Use C<GetChangeToken> to get the change token that you provide in the
1416 C<ChangeToken> parameter of an UpdateXssMatchSet request.
1417  
1418 =item 4.
1419  
1420 Submit an UpdateXssMatchSet request to specify the parts of web
1421 requests in which you want to allow, block, or count cross-site
1422 scripting attacks.
1423  
1424 =back
1425  
1426 For more information about how to use the AWS WAF API to allow or block
1427 HTTP requests, see the AWS WAF Developer Guide
1428 (https://docs.aws.amazon.com/waf/latest/developerguide/).
1429  
1430  
1431 =head2 DeleteByteMatchSet
1432  
1433 =over
1434  
1435 =item ByteMatchSetId => Str
1436  
1437 =item ChangeToken => Str
1438  
1439  
1440 =back
1441  
1442 Each argument is described in detail in: L<Paws::WAFRegional::DeleteByteMatchSet>
1443  
1444 Returns: a L<Paws::WAFRegional::DeleteByteMatchSetResponse> instance
1445  
1446 This is B<AWS WAF Classic> documentation. For more information, see AWS
1447 WAF Classic
1448 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1449 in the developer guide.
1450  
1451 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1452 AWS WAF Developer Guide
1453 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1454 With the latest version, AWS WAF has a single set of endpoints for
1455 regional and global use.
1456  
1457 Permanently deletes a ByteMatchSet. You can't delete a C<ByteMatchSet>
1458 if it's still used in any C<Rules> or if it still includes any
1459 ByteMatchTuple objects (any filters).
1460  
1461 If you just want to remove a C<ByteMatchSet> from a C<Rule>, use
1462 UpdateRule.
1463  
1464 To permanently delete a C<ByteMatchSet>, perform the following steps:
1465  
1466 =over
1467  
1468 =item 1.
1469  
1470 Update the C<ByteMatchSet> to remove filters, if any. For more
1471 information, see UpdateByteMatchSet.
1472  
1473 =item 2.
1474  
1475 Use GetChangeToken to get the change token that you provide in the
1476 C<ChangeToken> parameter of a C<DeleteByteMatchSet> request.
1477  
1478 =item 3.
1479  
1480 Submit a C<DeleteByteMatchSet> request.
1481  
1482 =back
1483  
1484  
1485  
1486 =head2 DeleteGeoMatchSet
1487  
1488 =over
1489  
1490 =item ChangeToken => Str
1491  
1492 =item GeoMatchSetId => Str
1493  
1494  
1495 =back
1496  
1497 Each argument is described in detail in: L<Paws::WAFRegional::DeleteGeoMatchSet>
1498  
1499 Returns: a L<Paws::WAFRegional::DeleteGeoMatchSetResponse> instance
1500  
1501 This is B<AWS WAF Classic> documentation. For more information, see AWS
1502 WAF Classic
1503 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1504 in the developer guide.
1505  
1506 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1507 AWS WAF Developer Guide
1508 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1509 With the latest version, AWS WAF has a single set of endpoints for
1510 regional and global use.
1511  
1512 Permanently deletes a GeoMatchSet. You can't delete a C<GeoMatchSet> if
1513 it's still used in any C<Rules> or if it still includes any countries.
1514  
1515 If you just want to remove a C<GeoMatchSet> from a C<Rule>, use
1516 UpdateRule.
1517  
1518 To permanently delete a C<GeoMatchSet> from AWS WAF, perform the
1519 following steps:
1520  
1521 =over
1522  
1523 =item 1.
1524  
1525 Update the C<GeoMatchSet> to remove any countries. For more
1526 information, see UpdateGeoMatchSet.
1527  
1528 =item 2.
1529  
1530 Use GetChangeToken to get the change token that you provide in the
1531 C<ChangeToken> parameter of a C<DeleteGeoMatchSet> request.
1532  
1533 =item 3.
1534  
1535 Submit a C<DeleteGeoMatchSet> request.
1536  
1537 =back
1538  
1539  
1540  
1541 =head2 DeleteIPSet
1542  
1543 =over
1544  
1545 =item ChangeToken => Str
1546  
1547 =item IPSetId => Str
1548  
1549  
1550 =back
1551  
1552 Each argument is described in detail in: L<Paws::WAFRegional::DeleteIPSet>
1553  
1554 Returns: a L<Paws::WAFRegional::DeleteIPSetResponse> instance
1555  
1556 This is B<AWS WAF Classic> documentation. For more information, see AWS
1557 WAF Classic
1558 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1559 in the developer guide.
1560  
1561 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1562 AWS WAF Developer Guide
1563 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1564 With the latest version, AWS WAF has a single set of endpoints for
1565 regional and global use.
1566  
1567 Permanently deletes an IPSet. You can't delete an C<IPSet> if it's
1568 still used in any C<Rules> or if it still includes any IP addresses.
1569  
1570 If you just want to remove an C<IPSet> from a C<Rule>, use UpdateRule.
1571  
1572 To permanently delete an C<IPSet> from AWS WAF, perform the following
1573 steps:
1574  
1575 =over
1576  
1577 =item 1.
1578  
1579 Update the C<IPSet> to remove IP address ranges, if any. For more
1580 information, see UpdateIPSet.
1581  
1582 =item 2.
1583  
1584 Use GetChangeToken to get the change token that you provide in the
1585 C<ChangeToken> parameter of a C<DeleteIPSet> request.
1586  
1587 =item 3.
1588  
1589 Submit a C<DeleteIPSet> request.
1590  
1591 =back
1592  
1593  
1594  
1595 =head2 DeleteLoggingConfiguration
1596  
1597 =over
1598  
1599 =item ResourceArn => Str
1600  
1601  
1602 =back
1603  
1604 Each argument is described in detail in: L<Paws::WAFRegional::DeleteLoggingConfiguration>
1605  
1606 Returns: a L<Paws::WAFRegional::DeleteLoggingConfigurationResponse> instance
1607  
1608 This is B<AWS WAF Classic> documentation. For more information, see AWS
1609 WAF Classic
1610 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1611 in the developer guide.
1612  
1613 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1614 AWS WAF Developer Guide
1615 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1616 With the latest version, AWS WAF has a single set of endpoints for
1617 regional and global use.
1618  
1619 Permanently deletes the LoggingConfiguration from the specified web
1620 ACL.
1621  
1622  
1623 =head2 DeletePermissionPolicy
1624  
1625 =over
1626  
1627 =item ResourceArn => Str
1628  
1629  
1630 =back
1631  
1632 Each argument is described in detail in: L<Paws::WAFRegional::DeletePermissionPolicy>
1633  
1634 Returns: a L<Paws::WAFRegional::DeletePermissionPolicyResponse> instance
1635  
1636 This is B<AWS WAF Classic> documentation. For more information, see AWS
1637 WAF Classic
1638 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1639 in the developer guide.
1640  
1641 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1642 AWS WAF Developer Guide
1643 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1644 With the latest version, AWS WAF has a single set of endpoints for
1645 regional and global use.
1646  
1647 Permanently deletes an IAM policy from the specified RuleGroup.
1648  
1649 The user making the request must be the owner of the RuleGroup.
1650  
1651  
1652 =head2 DeleteRateBasedRule
1653  
1654 =over
1655  
1656 =item ChangeToken => Str
1657  
1658 =item RuleId => Str
1659  
1660  
1661 =back
1662  
1663 Each argument is described in detail in: L<Paws::WAFRegional::DeleteRateBasedRule>
1664  
1665 Returns: a L<Paws::WAFRegional::DeleteRateBasedRuleResponse> instance
1666  
1667 This is B<AWS WAF Classic> documentation. For more information, see AWS
1668 WAF Classic
1669 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1670 in the developer guide.
1671  
1672 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1673 AWS WAF Developer Guide
1674 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1675 With the latest version, AWS WAF has a single set of endpoints for
1676 regional and global use.
1677  
1678 Permanently deletes a RateBasedRule. You can't delete a rule if it's
1679 still used in any C<WebACL> objects or if it still includes any
1680 predicates, such as C<ByteMatchSet> objects.
1681  
1682 If you just want to remove a rule from a C<WebACL>, use UpdateWebACL.
1683  
1684 To permanently delete a C<RateBasedRule> from AWS WAF, perform the
1685 following steps:
1686  
1687 =over
1688  
1689 =item 1.
1690  
1691 Update the C<RateBasedRule> to remove predicates, if any. For more
1692 information, see UpdateRateBasedRule.
1693  
1694 =item 2.
1695  
1696 Use GetChangeToken to get the change token that you provide in the
1697 C<ChangeToken> parameter of a C<DeleteRateBasedRule> request.
1698  
1699 =item 3.
1700  
1701 Submit a C<DeleteRateBasedRule> request.
1702  
1703 =back
1704  
1705  
1706  
1707 =head2 DeleteRegexMatchSet
1708  
1709 =over
1710  
1711 =item ChangeToken => Str
1712  
1713 =item RegexMatchSetId => Str
1714  
1715  
1716 =back
1717  
1718 Each argument is described in detail in: L<Paws::WAFRegional::DeleteRegexMatchSet>
1719  
1720 Returns: a L<Paws::WAFRegional::DeleteRegexMatchSetResponse> instance
1721  
1722 This is B<AWS WAF Classic> documentation. For more information, see AWS
1723 WAF Classic
1724 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1725 in the developer guide.
1726  
1727 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1728 AWS WAF Developer Guide
1729 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1730 With the latest version, AWS WAF has a single set of endpoints for
1731 regional and global use.
1732  
1733 Permanently deletes a RegexMatchSet. You can't delete a
1734 C<RegexMatchSet> if it's still used in any C<Rules> or if it still
1735 includes any C<RegexMatchTuples> objects (any filters).
1736  
1737 If you just want to remove a C<RegexMatchSet> from a C<Rule>, use
1738 UpdateRule.
1739  
1740 To permanently delete a C<RegexMatchSet>, perform the following steps:
1741  
1742 =over
1743  
1744 =item 1.
1745  
1746 Update the C<RegexMatchSet> to remove filters, if any. For more
1747 information, see UpdateRegexMatchSet.
1748  
1749 =item 2.
1750  
1751 Use GetChangeToken to get the change token that you provide in the
1752 C<ChangeToken> parameter of a C<DeleteRegexMatchSet> request.
1753  
1754 =item 3.
1755  
1756 Submit a C<DeleteRegexMatchSet> request.
1757  
1758 =back
1759  
1760  
1761  
1762 =head2 DeleteRegexPatternSet
1763  
1764 =over
1765  
1766 =item ChangeToken => Str
1767  
1768 =item RegexPatternSetId => Str
1769  
1770  
1771 =back
1772  
1773 Each argument is described in detail in: L<Paws::WAFRegional::DeleteRegexPatternSet>
1774  
1775 Returns: a L<Paws::WAFRegional::DeleteRegexPatternSetResponse> instance
1776  
1777 This is B<AWS WAF Classic> documentation. For more information, see AWS
1778 WAF Classic
1779 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1780 in the developer guide.
1781  
1782 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1783 AWS WAF Developer Guide
1784 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1785 With the latest version, AWS WAF has a single set of endpoints for
1786 regional and global use.
1787  
1788 Permanently deletes a RegexPatternSet. You can't delete a
1789 C<RegexPatternSet> if it's still used in any C<RegexMatchSet> or if the
1790 C<RegexPatternSet> is not empty.
1791  
1792  
1793 =head2 DeleteRule
1794  
1795 =over
1796  
1797 =item ChangeToken => Str
1798  
1799 =item RuleId => Str
1800  
1801  
1802 =back
1803  
1804 Each argument is described in detail in: L<Paws::WAFRegional::DeleteRule>
1805  
1806 Returns: a L<Paws::WAFRegional::DeleteRuleResponse> instance
1807  
1808 This is B<AWS WAF Classic> documentation. For more information, see AWS
1809 WAF Classic
1810 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1811 in the developer guide.
1812  
1813 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1814 AWS WAF Developer Guide
1815 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1816 With the latest version, AWS WAF has a single set of endpoints for
1817 regional and global use.
1818  
1819 Permanently deletes a Rule. You can't delete a C<Rule> if it's still
1820 used in any C<WebACL> objects or if it still includes any predicates,
1821 such as C<ByteMatchSet> objects.
1822  
1823 If you just want to remove a C<Rule> from a C<WebACL>, use
1824 UpdateWebACL.
1825  
1826 To permanently delete a C<Rule> from AWS WAF, perform the following
1827 steps:
1828  
1829 =over
1830  
1831 =item 1.
1832  
1833 Update the C<Rule> to remove predicates, if any. For more information,
1834 see UpdateRule.
1835  
1836 =item 2.
1837  
1838 Use GetChangeToken to get the change token that you provide in the
1839 C<ChangeToken> parameter of a C<DeleteRule> request.
1840  
1841 =item 3.
1842  
1843 Submit a C<DeleteRule> request.
1844  
1845 =back
1846  
1847  
1848  
1849 =head2 DeleteRuleGroup
1850  
1851 =over
1852  
1853 =item ChangeToken => Str
1854  
1855 =item RuleGroupId => Str
1856  
1857  
1858 =back
1859  
1860 Each argument is described in detail in: L<Paws::WAFRegional::DeleteRuleGroup>
1861  
1862 Returns: a L<Paws::WAFRegional::DeleteRuleGroupResponse> instance
1863  
1864 This is B<AWS WAF Classic> documentation. For more information, see AWS
1865 WAF Classic
1866 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1867 in the developer guide.
1868  
1869 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1870 AWS WAF Developer Guide
1871 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1872 With the latest version, AWS WAF has a single set of endpoints for
1873 regional and global use.
1874  
1875 Permanently deletes a RuleGroup. You can't delete a C<RuleGroup> if
1876 it's still used in any C<WebACL> objects or if it still includes any
1877 rules.
1878  
1879 If you just want to remove a C<RuleGroup> from a C<WebACL>, use
1880 UpdateWebACL.
1881  
1882 To permanently delete a C<RuleGroup> from AWS WAF, perform the
1883 following steps:
1884  
1885 =over
1886  
1887 =item 1.
1888  
1889 Update the C<RuleGroup> to remove rules, if any. For more information,
1890 see UpdateRuleGroup.
1891  
1892 =item 2.
1893  
1894 Use GetChangeToken to get the change token that you provide in the
1895 C<ChangeToken> parameter of a C<DeleteRuleGroup> request.
1896  
1897 =item 3.
1898  
1899 Submit a C<DeleteRuleGroup> request.
1900  
1901 =back
1902  
1903  
1904  
1905 =head2 DeleteSizeConstraintSet
1906  
1907 =over
1908  
1909 =item ChangeToken => Str
1910  
1911 =item SizeConstraintSetId => Str
1912  
1913  
1914 =back
1915  
1916 Each argument is described in detail in: L<Paws::WAFRegional::DeleteSizeConstraintSet>
1917  
1918 Returns: a L<Paws::WAFRegional::DeleteSizeConstraintSetResponse> instance
1919  
1920 This is B<AWS WAF Classic> documentation. For more information, see AWS
1921 WAF Classic
1922 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1923 in the developer guide.
1924  
1925 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1926 AWS WAF Developer Guide
1927 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1928 With the latest version, AWS WAF has a single set of endpoints for
1929 regional and global use.
1930  
1931 Permanently deletes a SizeConstraintSet. You can't delete a
1932 C<SizeConstraintSet> if it's still used in any C<Rules> or if it still
1933 includes any SizeConstraint objects (any filters).
1934  
1935 If you just want to remove a C<SizeConstraintSet> from a C<Rule>, use
1936 UpdateRule.
1937  
1938 To permanently delete a C<SizeConstraintSet>, perform the following
1939 steps:
1940  
1941 =over
1942  
1943 =item 1.
1944  
1945 Update the C<SizeConstraintSet> to remove filters, if any. For more
1946 information, see UpdateSizeConstraintSet.
1947  
1948 =item 2.
1949  
1950 Use GetChangeToken to get the change token that you provide in the
1951 C<ChangeToken> parameter of a C<DeleteSizeConstraintSet> request.
1952  
1953 =item 3.
1954  
1955 Submit a C<DeleteSizeConstraintSet> request.
1956  
1957 =back
1958  
1959  
1960  
1961 =head2 DeleteSqlInjectionMatchSet
1962  
1963 =over
1964  
1965 =item ChangeToken => Str
1966  
1967 =item SqlInjectionMatchSetId => Str
1968  
1969  
1970 =back
1971  
1972 Each argument is described in detail in: L<Paws::WAFRegional::DeleteSqlInjectionMatchSet>
1973  
1974 Returns: a L<Paws::WAFRegional::DeleteSqlInjectionMatchSetResponse> instance
1975  
1976 This is B<AWS WAF Classic> documentation. For more information, see AWS
1977 WAF Classic
1978 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
1979 in the developer guide.
1980  
1981 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
1982 AWS WAF Developer Guide
1983 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
1984 With the latest version, AWS WAF has a single set of endpoints for
1985 regional and global use.
1986  
1987 Permanently deletes a SqlInjectionMatchSet. You can't delete a
1988 C<SqlInjectionMatchSet> if it's still used in any C<Rules> or if it
1989 still contains any SqlInjectionMatchTuple objects.
1990  
1991 If you just want to remove a C<SqlInjectionMatchSet> from a C<Rule>,
1992 use UpdateRule.
1993  
1994 To permanently delete a C<SqlInjectionMatchSet> from AWS WAF, perform
1995 the following steps:
1996  
1997 =over
1998  
1999 =item 1.
2000  
2001 Update the C<SqlInjectionMatchSet> to remove filters, if any. For more
2002 information, see UpdateSqlInjectionMatchSet.
2003  
2004 =item 2.
2005  
2006 Use GetChangeToken to get the change token that you provide in the
2007 C<ChangeToken> parameter of a C<DeleteSqlInjectionMatchSet> request.
2008  
2009 =item 3.
2010  
2011 Submit a C<DeleteSqlInjectionMatchSet> request.
2012  
2013 =back
2014  
2015  
2016  
2017 =head2 DeleteWebACL
2018  
2019 =over
2020  
2021 =item ChangeToken => Str
2022  
2023 =item WebACLId => Str
2024  
2025  
2026 =back
2027  
2028 Each argument is described in detail in: L<Paws::WAFRegional::DeleteWebACL>
2029  
2030 Returns: a L<Paws::WAFRegional::DeleteWebACLResponse> instance
2031  
2032 This is B<AWS WAF Classic> documentation. For more information, see AWS
2033 WAF Classic
2034 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2035 in the developer guide.
2036  
2037 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2038 AWS WAF Developer Guide
2039 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2040 With the latest version, AWS WAF has a single set of endpoints for
2041 regional and global use.
2042  
2043 Permanently deletes a WebACL. You can't delete a C<WebACL> if it still
2044 contains any C<Rules>.
2045  
2046 To delete a C<WebACL>, perform the following steps:
2047  
2048 =over
2049  
2050 =item 1.
2051  
2052 Update the C<WebACL> to remove C<Rules>, if any. For more information,
2053 see UpdateWebACL.
2054  
2055 =item 2.
2056  
2057 Use GetChangeToken to get the change token that you provide in the
2058 C<ChangeToken> parameter of a C<DeleteWebACL> request.
2059  
2060 =item 3.
2061  
2062 Submit a C<DeleteWebACL> request.
2063  
2064 =back
2065  
2066  
2067  
2068 =head2 DeleteXssMatchSet
2069  
2070 =over
2071  
2072 =item ChangeToken => Str
2073  
2074 =item XssMatchSetId => Str
2075  
2076  
2077 =back
2078  
2079 Each argument is described in detail in: L<Paws::WAFRegional::DeleteXssMatchSet>
2080  
2081 Returns: a L<Paws::WAFRegional::DeleteXssMatchSetResponse> instance
2082  
2083 This is B<AWS WAF Classic> documentation. For more information, see AWS
2084 WAF Classic
2085 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2086 in the developer guide.
2087  
2088 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2089 AWS WAF Developer Guide
2090 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2091 With the latest version, AWS WAF has a single set of endpoints for
2092 regional and global use.
2093  
2094 Permanently deletes an XssMatchSet. You can't delete an C<XssMatchSet>
2095 if it's still used in any C<Rules> or if it still contains any
2096 XssMatchTuple objects.
2097  
2098 If you just want to remove an C<XssMatchSet> from a C<Rule>, use
2099 UpdateRule.
2100  
2101 To permanently delete an C<XssMatchSet> from AWS WAF, perform the
2102 following steps:
2103  
2104 =over
2105  
2106 =item 1.
2107  
2108 Update the C<XssMatchSet> to remove filters, if any. For more
2109 information, see UpdateXssMatchSet.
2110  
2111 =item 2.
2112  
2113 Use GetChangeToken to get the change token that you provide in the
2114 C<ChangeToken> parameter of a C<DeleteXssMatchSet> request.
2115  
2116 =item 3.
2117  
2118 Submit a C<DeleteXssMatchSet> request.
2119  
2120 =back
2121  
2122  
2123  
2124 =head2 DisassociateWebACL
2125  
2126 =over
2127  
2128 =item ResourceArn => Str
2129  
2130  
2131 =back
2132  
2133 Each argument is described in detail in: L<Paws::WAFRegional::DisassociateWebACL>
2134  
2135 Returns: a L<Paws::WAFRegional::DisassociateWebACLResponse> instance
2136  
2137 This is B<AWS WAF Classic Regional> documentation. For more
2138 information, see AWS WAF Classic
2139 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2140 in the developer guide.
2141  
2142 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2143 AWS WAF Developer Guide
2144 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2145 With the latest version, AWS WAF has a single set of endpoints for
2146 regional and global use.
2147  
2148 Removes a web ACL from the specified resource, either an application
2149 load balancer or Amazon API Gateway stage.
2150  
2151  
2152 =head2 GetByteMatchSet
2153  
2154 =over
2155  
2156 =item ByteMatchSetId => Str
2157  
2158  
2159 =back
2160  
2161 Each argument is described in detail in: L<Paws::WAFRegional::GetByteMatchSet>
2162  
2163 Returns: a L<Paws::WAFRegional::GetByteMatchSetResponse> instance
2164  
2165 This is B<AWS WAF Classic> documentation. For more information, see AWS
2166 WAF Classic
2167 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2168 in the developer guide.
2169  
2170 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2171 AWS WAF Developer Guide
2172 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2173 With the latest version, AWS WAF has a single set of endpoints for
2174 regional and global use.
2175  
2176 Returns the ByteMatchSet specified by C<ByteMatchSetId>.
2177  
2178  
2179 =head2 GetChangeToken
2180  
2181  
2182  
2183  
2184  
2185  
2186 Each argument is described in detail in: L<Paws::WAFRegional::GetChangeToken>
2187  
2188 Returns: a L<Paws::WAFRegional::GetChangeTokenResponse> instance
2189  
2190 This is B<AWS WAF Classic> documentation. For more information, see AWS
2191 WAF Classic
2192 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2193 in the developer guide.
2194  
2195 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2196 AWS WAF Developer Guide
2197 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2198 With the latest version, AWS WAF has a single set of endpoints for
2199 regional and global use.
2200  
2201 When you want to create, update, or delete AWS WAF objects, get a
2202 change token and include the change token in the create, update, or
2203 delete request. Change tokens ensure that your application doesn't
2204 submit conflicting requests to AWS WAF.
2205  
2206 Each create, update, or delete request must use a unique change token.
2207 If your application submits a C<GetChangeToken> request and then
2208 submits a second C<GetChangeToken> request before submitting a create,
2209 update, or delete request, the second C<GetChangeToken> request returns
2210 the same value as the first C<GetChangeToken> request.
2211  
2212 When you use a change token in a create, update, or delete request, the
2213 status of the change token changes to C<PENDING>, which indicates that
2214 AWS WAF is propagating the change to all AWS WAF servers. Use
2215 C<GetChangeTokenStatus> to determine the status of your change token.
2216  
2217  
2218 =head2 GetChangeTokenStatus
2219  
2220 =over
2221  
2222 =item ChangeToken => Str
2223  
2224  
2225 =back
2226  
2227 Each argument is described in detail in: L<Paws::WAFRegional::GetChangeTokenStatus>
2228  
2229 Returns: a L<Paws::WAFRegional::GetChangeTokenStatusResponse> instance
2230  
2231 This is B<AWS WAF Classic> documentation. For more information, see AWS
2232 WAF Classic
2233 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2234 in the developer guide.
2235  
2236 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2237 AWS WAF Developer Guide
2238 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2239 With the latest version, AWS WAF has a single set of endpoints for
2240 regional and global use.
2241  
2242 Returns the status of a C<ChangeToken> that you got by calling
2243 GetChangeToken. C<ChangeTokenStatus> is one of the following values:
2244  
2245 =over
2246  
2247 =item *
2248  
2249 C<PROVISIONED>: You requested the change token by calling
2250 C<GetChangeToken>, but you haven't used it yet in a call to create,
2251 update, or delete an AWS WAF object.
2252  
2253 =item *
2254  
2255 C<PENDING>: AWS WAF is propagating the create, update, or delete
2256 request to all AWS WAF servers.
2257  
2258 =item *
2259  
2260 C<INSYNC>: Propagation is complete.
2261  
2262 =back
2263  
2264  
2265  
2266 =head2 GetGeoMatchSet
2267  
2268 =over
2269  
2270 =item GeoMatchSetId => Str
2271  
2272  
2273 =back
2274  
2275 Each argument is described in detail in: L<Paws::WAFRegional::GetGeoMatchSet>
2276  
2277 Returns: a L<Paws::WAFRegional::GetGeoMatchSetResponse> instance
2278  
2279 This is B<AWS WAF Classic> documentation. For more information, see AWS
2280 WAF Classic
2281 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2282 in the developer guide.
2283  
2284 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2285 AWS WAF Developer Guide
2286 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2287 With the latest version, AWS WAF has a single set of endpoints for
2288 regional and global use.
2289  
2290 Returns the GeoMatchSet that is specified by C<GeoMatchSetId>.
2291  
2292  
2293 =head2 GetIPSet
2294  
2295 =over
2296  
2297 =item IPSetId => Str
2298  
2299  
2300 =back
2301  
2302 Each argument is described in detail in: L<Paws::WAFRegional::GetIPSet>
2303  
2304 Returns: a L<Paws::WAFRegional::GetIPSetResponse> instance
2305  
2306 This is B<AWS WAF Classic> documentation. For more information, see AWS
2307 WAF Classic
2308 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2309 in the developer guide.
2310  
2311 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2312 AWS WAF Developer Guide
2313 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2314 With the latest version, AWS WAF has a single set of endpoints for
2315 regional and global use.
2316  
2317 Returns the IPSet that is specified by C<IPSetId>.
2318  
2319  
2320 =head2 GetLoggingConfiguration
2321  
2322 =over
2323  
2324 =item ResourceArn => Str
2325  
2326  
2327 =back
2328  
2329 Each argument is described in detail in: L<Paws::WAFRegional::GetLoggingConfiguration>
2330  
2331 Returns: a L<Paws::WAFRegional::GetLoggingConfigurationResponse> instance
2332  
2333 This is B<AWS WAF Classic> documentation. For more information, see AWS
2334 WAF Classic
2335 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2336 in the developer guide.
2337  
2338 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2339 AWS WAF Developer Guide
2340 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2341 With the latest version, AWS WAF has a single set of endpoints for
2342 regional and global use.
2343  
2344 Returns the LoggingConfiguration for the specified web ACL.
2345  
2346  
2347 =head2 GetPermissionPolicy
2348  
2349 =over
2350  
2351 =item ResourceArn => Str
2352  
2353  
2354 =back
2355  
2356 Each argument is described in detail in: L<Paws::WAFRegional::GetPermissionPolicy>
2357  
2358 Returns: a L<Paws::WAFRegional::GetPermissionPolicyResponse> instance
2359  
2360 This is B<AWS WAF Classic> documentation. For more information, see AWS
2361 WAF Classic
2362 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2363 in the developer guide.
2364  
2365 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2366 AWS WAF Developer Guide
2367 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2368 With the latest version, AWS WAF has a single set of endpoints for
2369 regional and global use.
2370  
2371 Returns the IAM policy attached to the RuleGroup.
2372  
2373  
2374 =head2 GetRateBasedRule
2375  
2376 =over
2377  
2378 =item RuleId => Str
2379  
2380  
2381 =back
2382  
2383 Each argument is described in detail in: L<Paws::WAFRegional::GetRateBasedRule>
2384  
2385 Returns: a L<Paws::WAFRegional::GetRateBasedRuleResponse> instance
2386  
2387 This is B<AWS WAF Classic> documentation. For more information, see AWS
2388 WAF Classic
2389 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2390 in the developer guide.
2391  
2392 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2393 AWS WAF Developer Guide
2394 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2395 With the latest version, AWS WAF has a single set of endpoints for
2396 regional and global use.
2397  
2398 Returns the RateBasedRule that is specified by the C<RuleId> that you
2399 included in the C<GetRateBasedRule> request.
2400  
2401  
2402 =head2 GetRateBasedRuleManagedKeys
2403  
2404 =over
2405  
2406 =item RuleId => Str
2407  
2408 =item [NextMarker => Str]
2409  
2410  
2411 =back
2412  
2413 Each argument is described in detail in: L<Paws::WAFRegional::GetRateBasedRuleManagedKeys>
2414  
2415 Returns: a L<Paws::WAFRegional::GetRateBasedRuleManagedKeysResponse> instance
2416  
2417 This is B<AWS WAF Classic> documentation. For more information, see AWS
2418 WAF Classic
2419 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2420 in the developer guide.
2421  
2422 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2423 AWS WAF Developer Guide
2424 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2425 With the latest version, AWS WAF has a single set of endpoints for
2426 regional and global use.
2427  
2428 Returns an array of IP addresses currently being blocked by the
2429 RateBasedRule that is specified by the C<RuleId>. The maximum number of
2430 managed keys that will be blocked is 10,000. If more than 10,000
2431 addresses exceed the rate limit, the 10,000 addresses with the highest
2432 rates will be blocked.
2433  
2434  
2435 =head2 GetRegexMatchSet
2436  
2437 =over
2438  
2439 =item RegexMatchSetId => Str
2440  
2441  
2442 =back
2443  
2444 Each argument is described in detail in: L<Paws::WAFRegional::GetRegexMatchSet>
2445  
2446 Returns: a L<Paws::WAFRegional::GetRegexMatchSetResponse> instance
2447  
2448 This is B<AWS WAF Classic> documentation. For more information, see AWS
2449 WAF Classic
2450 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2451 in the developer guide.
2452  
2453 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2454 AWS WAF Developer Guide
2455 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2456 With the latest version, AWS WAF has a single set of endpoints for
2457 regional and global use.
2458  
2459 Returns the RegexMatchSet specified by C<RegexMatchSetId>.
2460  
2461  
2462 =head2 GetRegexPatternSet
2463  
2464 =over
2465  
2466 =item RegexPatternSetId => Str
2467  
2468  
2469 =back
2470  
2471 Each argument is described in detail in: L<Paws::WAFRegional::GetRegexPatternSet>
2472  
2473 Returns: a L<Paws::WAFRegional::GetRegexPatternSetResponse> instance
2474  
2475 This is B<AWS WAF Classic> documentation. For more information, see AWS
2476 WAF Classic
2477 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2478 in the developer guide.
2479  
2480 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2481 AWS WAF Developer Guide
2482 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2483 With the latest version, AWS WAF has a single set of endpoints for
2484 regional and global use.
2485  
2486 Returns the RegexPatternSet specified by C<RegexPatternSetId>.
2487  
2488  
2489 =head2 GetRule
2490  
2491 =over
2492  
2493 =item RuleId => Str
2494  
2495  
2496 =back
2497  
2498 Each argument is described in detail in: L<Paws::WAFRegional::GetRule>
2499  
2500 Returns: a L<Paws::WAFRegional::GetRuleResponse> instance
2501  
2502 This is B<AWS WAF Classic> documentation. For more information, see AWS
2503 WAF Classic
2504 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2505 in the developer guide.
2506  
2507 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2508 AWS WAF Developer Guide
2509 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2510 With the latest version, AWS WAF has a single set of endpoints for
2511 regional and global use.
2512  
2513 Returns the Rule that is specified by the C<RuleId> that you included
2514 in the C<GetRule> request.
2515  
2516  
2517 =head2 GetRuleGroup
2518  
2519 =over
2520  
2521 =item RuleGroupId => Str
2522  
2523  
2524 =back
2525  
2526 Each argument is described in detail in: L<Paws::WAFRegional::GetRuleGroup>
2527  
2528 Returns: a L<Paws::WAFRegional::GetRuleGroupResponse> instance
2529  
2530 This is B<AWS WAF Classic> documentation. For more information, see AWS
2531 WAF Classic
2532 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2533 in the developer guide.
2534  
2535 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2536 AWS WAF Developer Guide
2537 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2538 With the latest version, AWS WAF has a single set of endpoints for
2539 regional and global use.
2540  
2541 Returns the RuleGroup that is specified by the C<RuleGroupId> that you
2542 included in the C<GetRuleGroup> request.
2543  
2544 To view the rules in a rule group, use ListActivatedRulesInRuleGroup.
2545  
2546  
2547 =head2 GetSampledRequests
2548  
2549 =over
2550  
2551 =item MaxItems => Int
2552  
2553 =item RuleId => Str
2554  
2555 =item TimeWindow => L<Paws::WAFRegional::TimeWindow>
2556  
2557 =item WebAclId => Str
2558  
2559  
2560 =back
2561  
2562 Each argument is described in detail in: L<Paws::WAFRegional::GetSampledRequests>
2563  
2564 Returns: a L<Paws::WAFRegional::GetSampledRequestsResponse> instance
2565  
2566 This is B<AWS WAF Classic> documentation. For more information, see AWS
2567 WAF Classic
2568 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2569 in the developer guide.
2570  
2571 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2572 AWS WAF Developer Guide
2573 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2574 With the latest version, AWS WAF has a single set of endpoints for
2575 regional and global use.
2576  
2577 Gets detailed information about a specified number of requests--a
2578 sample--that AWS WAF randomly selects from among the first 5,000
2579 requests that your AWS resource received during a time range that you
2580 choose. You can specify a sample size of up to 500 requests, and you
2581 can specify any time range in the previous three hours.
2582  
2583 C<GetSampledRequests> returns a time range, which is usually the time
2584 range that you specified. However, if your resource (such as a
2585 CloudFront distribution) received 5,000 requests before the specified
2586 time range elapsed, C<GetSampledRequests> returns an updated time
2587 range. This new time range indicates the actual period during which AWS
2588 WAF selected the requests in the sample.
2589  
2590  
2591 =head2 GetSizeConstraintSet
2592  
2593 =over
2594  
2595 =item SizeConstraintSetId => Str
2596  
2597  
2598 =back
2599  
2600 Each argument is described in detail in: L<Paws::WAFRegional::GetSizeConstraintSet>
2601  
2602 Returns: a L<Paws::WAFRegional::GetSizeConstraintSetResponse> instance
2603  
2604 This is B<AWS WAF Classic> documentation. For more information, see AWS
2605 WAF Classic
2606 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2607 in the developer guide.
2608  
2609 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2610 AWS WAF Developer Guide
2611 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2612 With the latest version, AWS WAF has a single set of endpoints for
2613 regional and global use.
2614  
2615 Returns the SizeConstraintSet specified by C<SizeConstraintSetId>.
2616  
2617  
2618 =head2 GetSqlInjectionMatchSet
2619  
2620 =over
2621  
2622 =item SqlInjectionMatchSetId => Str
2623  
2624  
2625 =back
2626  
2627 Each argument is described in detail in: L<Paws::WAFRegional::GetSqlInjectionMatchSet>
2628  
2629 Returns: a L<Paws::WAFRegional::GetSqlInjectionMatchSetResponse> instance
2630  
2631 This is B<AWS WAF Classic> documentation. For more information, see AWS
2632 WAF Classic
2633 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2634 in the developer guide.
2635  
2636 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2637 AWS WAF Developer Guide
2638 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2639 With the latest version, AWS WAF has a single set of endpoints for
2640 regional and global use.
2641  
2642 Returns the SqlInjectionMatchSet that is specified by
2643 C<SqlInjectionMatchSetId>.
2644  
2645  
2646 =head2 GetWebACL
2647  
2648 =over
2649  
2650 =item WebACLId => Str
2651  
2652  
2653 =back
2654  
2655 Each argument is described in detail in: L<Paws::WAFRegional::GetWebACL>
2656  
2657 Returns: a L<Paws::WAFRegional::GetWebACLResponse> instance
2658  
2659 This is B<AWS WAF Classic> documentation. For more information, see AWS
2660 WAF Classic
2661 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2662 in the developer guide.
2663  
2664 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2665 AWS WAF Developer Guide
2666 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2667 With the latest version, AWS WAF has a single set of endpoints for
2668 regional and global use.
2669  
2670 Returns the WebACL that is specified by C<WebACLId>.
2671  
2672  
2673 =head2 GetWebACLForResource
2674  
2675 =over
2676  
2677 =item ResourceArn => Str
2678  
2679  
2680 =back
2681  
2682 Each argument is described in detail in: L<Paws::WAFRegional::GetWebACLForResource>
2683  
2684 Returns: a L<Paws::WAFRegional::GetWebACLForResourceResponse> instance
2685  
2686 This is B<AWS WAF Classic Regional> documentation. For more
2687 information, see AWS WAF Classic
2688 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2689 in the developer guide.
2690  
2691 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2692 AWS WAF Developer Guide
2693 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2694 With the latest version, AWS WAF has a single set of endpoints for
2695 regional and global use.
2696  
2697 Returns the web ACL for the specified resource, either an application
2698 load balancer or Amazon API Gateway stage.
2699  
2700  
2701 =head2 GetXssMatchSet
2702  
2703 =over
2704  
2705 =item XssMatchSetId => Str
2706  
2707  
2708 =back
2709  
2710 Each argument is described in detail in: L<Paws::WAFRegional::GetXssMatchSet>
2711  
2712 Returns: a L<Paws::WAFRegional::GetXssMatchSetResponse> instance
2713  
2714 This is B<AWS WAF Classic> documentation. For more information, see AWS
2715 WAF Classic
2716 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2717 in the developer guide.
2718  
2719 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2720 AWS WAF Developer Guide
2721 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2722 With the latest version, AWS WAF has a single set of endpoints for
2723 regional and global use.
2724  
2725 Returns the XssMatchSet that is specified by C<XssMatchSetId>.
2726  
2727  
2728 =head2 ListActivatedRulesInRuleGroup
2729  
2730 =over
2731  
2732 =item [Limit => Int]
2733  
2734 =item [NextMarker => Str]
2735  
2736 =item [RuleGroupId => Str]
2737  
2738  
2739 =back
2740  
2741 Each argument is described in detail in: L<Paws::WAFRegional::ListActivatedRulesInRuleGroup>
2742  
2743 Returns: a L<Paws::WAFRegional::ListActivatedRulesInRuleGroupResponse> instance
2744  
2745 This is B<AWS WAF Classic> documentation. For more information, see AWS
2746 WAF Classic
2747 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2748 in the developer guide.
2749  
2750 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2751 AWS WAF Developer Guide
2752 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2753 With the latest version, AWS WAF has a single set of endpoints for
2754 regional and global use.
2755  
2756 Returns an array of ActivatedRule objects.
2757  
2758  
2759 =head2 ListByteMatchSets
2760  
2761 =over
2762  
2763 =item [Limit => Int]
2764  
2765 =item [NextMarker => Str]
2766  
2767  
2768 =back
2769  
2770 Each argument is described in detail in: L<Paws::WAFRegional::ListByteMatchSets>
2771  
2772 Returns: a L<Paws::WAFRegional::ListByteMatchSetsResponse> instance
2773  
2774 This is B<AWS WAF Classic> documentation. For more information, see AWS
2775 WAF Classic
2776 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2777 in the developer guide.
2778  
2779 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2780 AWS WAF Developer Guide
2781 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2782 With the latest version, AWS WAF has a single set of endpoints for
2783 regional and global use.
2784  
2785 Returns an array of ByteMatchSetSummary objects.
2786  
2787  
2788 =head2 ListGeoMatchSets
2789  
2790 =over
2791  
2792 =item [Limit => Int]
2793  
2794 =item [NextMarker => Str]
2795  
2796  
2797 =back
2798  
2799 Each argument is described in detail in: L<Paws::WAFRegional::ListGeoMatchSets>
2800  
2801 Returns: a L<Paws::WAFRegional::ListGeoMatchSetsResponse> instance
2802  
2803 This is B<AWS WAF Classic> documentation. For more information, see AWS
2804 WAF Classic
2805 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2806 in the developer guide.
2807  
2808 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2809 AWS WAF Developer Guide
2810 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2811 With the latest version, AWS WAF has a single set of endpoints for
2812 regional and global use.
2813  
2814 Returns an array of GeoMatchSetSummary objects in the response.
2815  
2816  
2817 =head2 ListIPSets
2818  
2819 =over
2820  
2821 =item [Limit => Int]
2822  
2823 =item [NextMarker => Str]
2824  
2825  
2826 =back
2827  
2828 Each argument is described in detail in: L<Paws::WAFRegional::ListIPSets>
2829  
2830 Returns: a L<Paws::WAFRegional::ListIPSetsResponse> instance
2831  
2832 This is B<AWS WAF Classic> documentation. For more information, see AWS
2833 WAF Classic
2834 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2835 in the developer guide.
2836  
2837 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2838 AWS WAF Developer Guide
2839 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2840 With the latest version, AWS WAF has a single set of endpoints for
2841 regional and global use.
2842  
2843 Returns an array of IPSetSummary objects in the response.
2844  
2845  
2846 =head2 ListLoggingConfigurations
2847  
2848 =over
2849  
2850 =item [Limit => Int]
2851  
2852 =item [NextMarker => Str]
2853  
2854  
2855 =back
2856  
2857 Each argument is described in detail in: L<Paws::WAFRegional::ListLoggingConfigurations>
2858  
2859 Returns: a L<Paws::WAFRegional::ListLoggingConfigurationsResponse> instance
2860  
2861 This is B<AWS WAF Classic> documentation. For more information, see AWS
2862 WAF Classic
2863 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2864 in the developer guide.
2865  
2866 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2867 AWS WAF Developer Guide
2868 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2869 With the latest version, AWS WAF has a single set of endpoints for
2870 regional and global use.
2871  
2872 Returns an array of LoggingConfiguration objects.
2873  
2874  
2875 =head2 ListRateBasedRules
2876  
2877 =over
2878  
2879 =item [Limit => Int]
2880  
2881 =item [NextMarker => Str]
2882  
2883  
2884 =back
2885  
2886 Each argument is described in detail in: L<Paws::WAFRegional::ListRateBasedRules>
2887  
2888 Returns: a L<Paws::WAFRegional::ListRateBasedRulesResponse> instance
2889  
2890 This is B<AWS WAF Classic> documentation. For more information, see AWS
2891 WAF Classic
2892 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2893 in the developer guide.
2894  
2895 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2896 AWS WAF Developer Guide
2897 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2898 With the latest version, AWS WAF has a single set of endpoints for
2899 regional and global use.
2900  
2901 Returns an array of RuleSummary objects.
2902  
2903  
2904 =head2 ListRegexMatchSets
2905  
2906 =over
2907  
2908 =item [Limit => Int]
2909  
2910 =item [NextMarker => Str]
2911  
2912  
2913 =back
2914  
2915 Each argument is described in detail in: L<Paws::WAFRegional::ListRegexMatchSets>
2916  
2917 Returns: a L<Paws::WAFRegional::ListRegexMatchSetsResponse> instance
2918  
2919 This is B<AWS WAF Classic> documentation. For more information, see AWS
2920 WAF Classic
2921 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2922 in the developer guide.
2923  
2924 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2925 AWS WAF Developer Guide
2926 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2927 With the latest version, AWS WAF has a single set of endpoints for
2928 regional and global use.
2929  
2930 Returns an array of RegexMatchSetSummary objects.
2931  
2932  
2933 =head2 ListRegexPatternSets
2934  
2935 =over
2936  
2937 =item [Limit => Int]
2938  
2939 =item [NextMarker => Str]
2940  
2941  
2942 =back
2943  
2944 Each argument is described in detail in: L<Paws::WAFRegional::ListRegexPatternSets>
2945  
2946 Returns: a L<Paws::WAFRegional::ListRegexPatternSetsResponse> instance
2947  
2948 This is B<AWS WAF Classic> documentation. For more information, see AWS
2949 WAF Classic
2950 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2951 in the developer guide.
2952  
2953 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2954 AWS WAF Developer Guide
2955 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2956 With the latest version, AWS WAF has a single set of endpoints for
2957 regional and global use.
2958  
2959 Returns an array of RegexPatternSetSummary objects.
2960  
2961  
2962 =head2 ListResourcesForWebACL
2963  
2964 =over
2965  
2966 =item WebACLId => Str
2967  
2968 =item [ResourceType => Str]
2969  
2970  
2971 =back
2972  
2973 Each argument is described in detail in: L<Paws::WAFRegional::ListResourcesForWebACL>
2974  
2975 Returns: a L<Paws::WAFRegional::ListResourcesForWebACLResponse> instance
2976  
2977 This is B<AWS WAF Classic Regional> documentation. For more
2978 information, see AWS WAF Classic
2979 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
2980 in the developer guide.
2981  
2982 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
2983 AWS WAF Developer Guide
2984 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
2985 With the latest version, AWS WAF has a single set of endpoints for
2986 regional and global use.
2987  
2988 Returns an array of resources associated with the specified web ACL.
2989  
2990  
2991 =head2 ListRuleGroups
2992  
2993 =over
2994  
2995 =item [Limit => Int]
2996  
2997 =item [NextMarker => Str]
2998  
2999  
3000 =back
3001  
3002 Each argument is described in detail in: L<Paws::WAFRegional::ListRuleGroups>
3003  
3004 Returns: a L<Paws::WAFRegional::ListRuleGroupsResponse> instance
3005  
3006 This is B<AWS WAF Classic> documentation. For more information, see AWS
3007 WAF Classic
3008 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3009 in the developer guide.
3010  
3011 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3012 AWS WAF Developer Guide
3013 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3014 With the latest version, AWS WAF has a single set of endpoints for
3015 regional and global use.
3016  
3017 Returns an array of RuleGroup objects.
3018  
3019  
3020 =head2 ListRules
3021  
3022 =over
3023  
3024 =item [Limit => Int]
3025  
3026 =item [NextMarker => Str]
3027  
3028  
3029 =back
3030  
3031 Each argument is described in detail in: L<Paws::WAFRegional::ListRules>
3032  
3033 Returns: a L<Paws::WAFRegional::ListRulesResponse> instance
3034  
3035 This is B<AWS WAF Classic> documentation. For more information, see AWS
3036 WAF Classic
3037 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3038 in the developer guide.
3039  
3040 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3041 AWS WAF Developer Guide
3042 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3043 With the latest version, AWS WAF has a single set of endpoints for
3044 regional and global use.
3045  
3046 Returns an array of RuleSummary objects.
3047  
3048  
3049 =head2 ListSizeConstraintSets
3050  
3051 =over
3052  
3053 =item [Limit => Int]
3054  
3055 =item [NextMarker => Str]
3056  
3057  
3058 =back
3059  
3060 Each argument is described in detail in: L<Paws::WAFRegional::ListSizeConstraintSets>
3061  
3062 Returns: a L<Paws::WAFRegional::ListSizeConstraintSetsResponse> instance
3063  
3064 This is B<AWS WAF Classic> documentation. For more information, see AWS
3065 WAF Classic
3066 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3067 in the developer guide.
3068  
3069 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3070 AWS WAF Developer Guide
3071 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3072 With the latest version, AWS WAF has a single set of endpoints for
3073 regional and global use.
3074  
3075 Returns an array of SizeConstraintSetSummary objects.
3076  
3077  
3078 =head2 ListSqlInjectionMatchSets
3079  
3080 =over
3081  
3082 =item [Limit => Int]
3083  
3084 =item [NextMarker => Str]
3085  
3086  
3087 =back
3088  
3089 Each argument is described in detail in: L<Paws::WAFRegional::ListSqlInjectionMatchSets>
3090  
3091 Returns: a L<Paws::WAFRegional::ListSqlInjectionMatchSetsResponse> instance
3092  
3093 This is B<AWS WAF Classic> documentation. For more information, see AWS
3094 WAF Classic
3095 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3096 in the developer guide.
3097  
3098 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3099 AWS WAF Developer Guide
3100 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3101 With the latest version, AWS WAF has a single set of endpoints for
3102 regional and global use.
3103  
3104 Returns an array of SqlInjectionMatchSet objects.
3105  
3106  
3107 =head2 ListSubscribedRuleGroups
3108  
3109 =over
3110  
3111 =item [Limit => Int]
3112  
3113 =item [NextMarker => Str]
3114  
3115  
3116 =back
3117  
3118 Each argument is described in detail in: L<Paws::WAFRegional::ListSubscribedRuleGroups>
3119  
3120 Returns: a L<Paws::WAFRegional::ListSubscribedRuleGroupsResponse> instance
3121  
3122 This is B<AWS WAF Classic> documentation. For more information, see AWS
3123 WAF Classic
3124 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3125 in the developer guide.
3126  
3127 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3128 AWS WAF Developer Guide
3129 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3130 With the latest version, AWS WAF has a single set of endpoints for
3131 regional and global use.
3132  
3133 Returns an array of RuleGroup objects that you are subscribed to.
3134  
3135  
3136 =head2 ListTagsForResource
3137  
3138 =over
3139  
3140 =item ResourceARN => Str
3141  
3142 =item [Limit => Int]
3143  
3144 =item [NextMarker => Str]
3145  
3146  
3147 =back
3148  
3149 Each argument is described in detail in: L<Paws::WAFRegional::ListTagsForResource>
3150  
3151 Returns: a L<Paws::WAFRegional::ListTagsForResourceResponse> instance
3152  
3153 This is B<AWS WAF Classic> documentation. For more information, see AWS
3154 WAF Classic
3155 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3156 in the developer guide.
3157  
3158 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3159 AWS WAF Developer Guide
3160 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3161 With the latest version, AWS WAF has a single set of endpoints for
3162 regional and global use.
3163  
3164 Retrieves the tags associated with the specified AWS resource. Tags are
3165 key:value pairs that you can use to categorize and manage your
3166 resources, for purposes like billing. For example, you might set the
3167 tag key to "customer" and the value to the customer name or ID. You can
3168 specify one or more tags to add to each AWS resource, up to 50 tags for
3169 a resource.
3170  
3171 Tagging is only available through the API, SDKs, and CLI. You can't
3172 manage or view tags through the AWS WAF Classic console. You can tag
3173 the AWS resources that you manage through AWS WAF Classic: web ACLs,
3174 rule groups, and rules.
3175  
3176  
3177 =head2 ListWebACLs
3178  
3179 =over
3180  
3181 =item [Limit => Int]
3182  
3183 =item [NextMarker => Str]
3184  
3185  
3186 =back
3187  
3188 Each argument is described in detail in: L<Paws::WAFRegional::ListWebACLs>
3189  
3190 Returns: a L<Paws::WAFRegional::ListWebACLsResponse> instance
3191  
3192 This is B<AWS WAF Classic> documentation. For more information, see AWS
3193 WAF Classic
3194 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3195 in the developer guide.
3196  
3197 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3198 AWS WAF Developer Guide
3199 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3200 With the latest version, AWS WAF has a single set of endpoints for
3201 regional and global use.
3202  
3203 Returns an array of WebACLSummary objects in the response.
3204  
3205  
3206 =head2 ListXssMatchSets
3207  
3208 =over
3209  
3210 =item [Limit => Int]
3211  
3212 =item [NextMarker => Str]
3213  
3214  
3215 =back
3216  
3217 Each argument is described in detail in: L<Paws::WAFRegional::ListXssMatchSets>
3218  
3219 Returns: a L<Paws::WAFRegional::ListXssMatchSetsResponse> instance
3220  
3221 This is B<AWS WAF Classic> documentation. For more information, see AWS
3222 WAF Classic
3223 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3224 in the developer guide.
3225  
3226 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3227 AWS WAF Developer Guide
3228 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3229 With the latest version, AWS WAF has a single set of endpoints for
3230 regional and global use.
3231  
3232 Returns an array of XssMatchSet objects.
3233  
3234  
3235 =head2 PutLoggingConfiguration
3236  
3237 =over
3238  
3239 =item LoggingConfiguration => L<Paws::WAFRegional::LoggingConfiguration>
3240  
3241  
3242 =back
3243  
3244 Each argument is described in detail in: L<Paws::WAFRegional::PutLoggingConfiguration>
3245  
3246 Returns: a L<Paws::WAFRegional::PutLoggingConfigurationResponse> instance
3247  
3248 This is B<AWS WAF Classic> documentation. For more information, see AWS
3249 WAF Classic
3250 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3251 in the developer guide.
3252  
3253 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3254 AWS WAF Developer Guide
3255 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3256 With the latest version, AWS WAF has a single set of endpoints for
3257 regional and global use.
3258  
3259 Associates a LoggingConfiguration with a specified web ACL.
3260  
3261 You can access information about all traffic that AWS WAF inspects
3262 using the following steps:
3263  
3264 =over
3265  
3266 =item 1.
3267  
3268 Create an Amazon Kinesis Data Firehose.
3269  
3270 Create the data firehose with a PUT source and in the region that you
3271 are operating. However, if you are capturing logs for Amazon
3272 CloudFront, always create the firehose in US East (N. Virginia).
3273  
3274 Do not create the data firehose using a C<Kinesis stream> as your
3275 source.
3276  
3277 =item 2.
3278  
3279 Associate that firehose to your web ACL using a
3280 C<PutLoggingConfiguration> request.
3281  
3282 =back
3283  
3284 When you successfully enable logging using a C<PutLoggingConfiguration>
3285 request, AWS WAF will create a service linked role with the necessary
3286 permissions to write logs to the Amazon Kinesis Data Firehose. For more
3287 information, see Logging Web ACL Traffic Information
3288 (https://docs.aws.amazon.com/waf/latest/developerguide/logging.html) in
3289 the I<AWS WAF Developer Guide>.
3290  
3291  
3292 =head2 PutPermissionPolicy
3293  
3294 =over
3295  
3296 =item Policy => Str
3297  
3298 =item ResourceArn => Str
3299  
3300  
3301 =back
3302  
3303 Each argument is described in detail in: L<Paws::WAFRegional::PutPermissionPolicy>
3304  
3305 Returns: a L<Paws::WAFRegional::PutPermissionPolicyResponse> instance
3306  
3307 This is B<AWS WAF Classic> documentation. For more information, see AWS
3308 WAF Classic
3309 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3310 in the developer guide.
3311  
3312 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3313 AWS WAF Developer Guide
3314 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3315 With the latest version, AWS WAF has a single set of endpoints for
3316 regional and global use.
3317  
3318 Attaches an IAM policy to the specified resource. The only supported
3319 use for this action is to share a RuleGroup across accounts.
3320  
3321 The C<PutPermissionPolicy> is subject to the following restrictions:
3322  
3323 =over
3324  
3325 =item *
3326  
3327 You can attach only one policy with each C<PutPermissionPolicy>
3328 request.
3329  
3330 =item *
3331  
3332 The policy must include an C<Effect>, C<Action> and C<Principal>.
3333  
3334 =item *
3335  
3336 C<Effect> must specify C<Allow>.
3337  
3338 =item *
3339  
3340 The C<Action> in the policy must be C<waf:UpdateWebACL>,
3341 C<waf-regional:UpdateWebACL>, C<waf:GetRuleGroup> and
3342 C<waf-regional:GetRuleGroup> . Any extra or wildcard actions in the
3343 policy will be rejected.
3344  
3345 =item *
3346  
3347 The policy cannot include a C<Resource> parameter.
3348  
3349 =item *
3350  
3351 The ARN in the request must be a valid WAF RuleGroup ARN and the
3352 RuleGroup must exist in the same region.
3353  
3354 =item *
3355  
3356 The user making the request must be the owner of the RuleGroup.
3357  
3358 =item *
3359  
3360 Your policy must be composed using IAM Policy version 2012-10-17.
3361  
3362 =back
3363  
3364 For more information, see IAM Policies
3365 (https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html).
3366  
3367 An example of a valid policy parameter is shown in the Examples section
3368 below.
3369  
3370  
3371 =head2 TagResource
3372  
3373 =over
3374  
3375 =item ResourceARN => Str
3376  
3377 =item Tags => ArrayRef[L<Paws::WAFRegional::Tag>]
3378  
3379  
3380 =back
3381  
3382 Each argument is described in detail in: L<Paws::WAFRegional::TagResource>
3383  
3384 Returns: a L<Paws::WAFRegional::TagResourceResponse> instance
3385  
3386 This is B<AWS WAF Classic> documentation. For more information, see AWS
3387 WAF Classic
3388 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3389 in the developer guide.
3390  
3391 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3392 AWS WAF Developer Guide
3393 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3394 With the latest version, AWS WAF has a single set of endpoints for
3395 regional and global use.
3396  
3397 Associates tags with the specified AWS resource. Tags are key:value
3398 pairs that you can use to categorize and manage your resources, for
3399 purposes like billing. For example, you might set the tag key to
3400 "customer" and the value to the customer name or ID. You can specify
3401 one or more tags to add to each AWS resource, up to 50 tags for a
3402 resource.
3403  
3404 Tagging is only available through the API, SDKs, and CLI. You can't
3405 manage or view tags through the AWS WAF Classic console. You can use
3406 this action to tag the AWS resources that you manage through AWS WAF
3407 Classic: web ACLs, rule groups, and rules.
3408  
3409  
3410 =head2 UntagResource
3411  
3412 =over
3413  
3414 =item ResourceARN => Str
3415  
3416 =item TagKeys => ArrayRef[Str|Undef]
3417  
3418  
3419 =back
3420  
3421 Each argument is described in detail in: L<Paws::WAFRegional::UntagResource>
3422  
3423 Returns: a L<Paws::WAFRegional::UntagResourceResponse> instance
3424  
3425 This is B<AWS WAF Classic> documentation. For more information, see AWS
3426 WAF Classic
3427 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3428 in the developer guide.
3429  
3430 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3431 AWS WAF Developer Guide
3432 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3433 With the latest version, AWS WAF has a single set of endpoints for
3434 regional and global use.
3435  
3436  
3437 =head2 UpdateByteMatchSet
3438  
3439 =over
3440  
3441 =item ByteMatchSetId => Str
3442  
3443 =item ChangeToken => Str
3444  
3445 =item Updates => ArrayRef[L<Paws::WAFRegional::ByteMatchSetUpdate>]
3446  
3447  
3448 =back
3449  
3450 Each argument is described in detail in: L<Paws::WAFRegional::UpdateByteMatchSet>
3451  
3452 Returns: a L<Paws::WAFRegional::UpdateByteMatchSetResponse> instance
3453  
3454 This is B<AWS WAF Classic> documentation. For more information, see AWS
3455 WAF Classic
3456 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3457 in the developer guide.
3458  
3459 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3460 AWS WAF Developer Guide
3461 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3462 With the latest version, AWS WAF has a single set of endpoints for
3463 regional and global use.
3464  
3465 Inserts or deletes ByteMatchTuple objects (filters) in a ByteMatchSet.
3466 For each C<ByteMatchTuple> object, you specify the following values:
3467  
3468 =over
3469  
3470 =item *
3471  
3472 Whether to insert or delete the object from the array. If you want to
3473 change a C<ByteMatchSetUpdate> object, you delete the existing object
3474 and add a new one.
3475  
3476 =item *
3477  
3478 The part of a web request that you want AWS WAF to inspect, such as a
3479 query string or the value of the C<User-Agent> header.
3480  
3481 =item *
3482  
3483 The bytes (typically a string that corresponds with ASCII characters)
3484 that you want AWS WAF to look for. For more information, including how
3485 you specify the values for the AWS WAF API and the AWS CLI or SDKs, see
3486 C<TargetString> in the ByteMatchTuple data type.
3487  
3488 =item *
3489  
3490 Where to look, such as at the beginning or the end of a query string.
3491  
3492 =item *
3493  
3494 Whether to perform any conversions on the request, such as converting
3495 it to lowercase, before inspecting it for the specified string.
3496  
3497 =back
3498  
3499 For example, you can add a C<ByteMatchSetUpdate> object that matches
3500 web requests in which C<User-Agent> headers contain the string
3501 C<BadBot>. You can then configure AWS WAF to block those requests.
3502  
3503 To create and configure a C<ByteMatchSet>, perform the following steps:
3504  
3505 =over
3506  
3507 =item 1.
3508  
3509 Create a C<ByteMatchSet.> For more information, see CreateByteMatchSet.
3510  
3511 =item 2.
3512  
3513 Use GetChangeToken to get the change token that you provide in the
3514 C<ChangeToken> parameter of an C<UpdateByteMatchSet> request.
3515  
3516 =item 3.
3517  
3518 Submit an C<UpdateByteMatchSet> request to specify the part of the
3519 request that you want AWS WAF to inspect (for example, the header or
3520 the URI) and the value that you want AWS WAF to watch for.
3521  
3522 =back
3523  
3524 For more information about how to use the AWS WAF API to allow or block
3525 HTTP requests, see the AWS WAF Developer Guide
3526 (https://docs.aws.amazon.com/waf/latest/developerguide/).
3527  
3528  
3529 =head2 UpdateGeoMatchSet
3530  
3531 =over
3532  
3533 =item ChangeToken => Str
3534  
3535 =item GeoMatchSetId => Str
3536  
3537 =item Updates => ArrayRef[L<Paws::WAFRegional::GeoMatchSetUpdate>]
3538  
3539  
3540 =back
3541  
3542 Each argument is described in detail in: L<Paws::WAFRegional::UpdateGeoMatchSet>
3543  
3544 Returns: a L<Paws::WAFRegional::UpdateGeoMatchSetResponse> instance
3545  
3546 This is B<AWS WAF Classic> documentation. For more information, see AWS
3547 WAF Classic
3548 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3549 in the developer guide.
3550  
3551 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3552 AWS WAF Developer Guide
3553 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3554 With the latest version, AWS WAF has a single set of endpoints for
3555 regional and global use.
3556  
3557 Inserts or deletes GeoMatchConstraint objects in an C<GeoMatchSet>. For
3558 each C<GeoMatchConstraint> object, you specify the following values:
3559  
3560 =over
3561  
3562 =item *
3563  
3564 Whether to insert or delete the object from the array. If you want to
3565 change an C<GeoMatchConstraint> object, you delete the existing object
3566 and add a new one.
3567  
3568 =item *
3569  
3570 The C<Type>. The only valid value for C<Type> is C<Country>.
3571  
3572 =item *
3573  
3574 The C<Value>, which is a two character code for the country to add to
3575 the C<GeoMatchConstraint> object. Valid codes are listed in
3576 GeoMatchConstraint$Value.
3577  
3578 =back
3579  
3580 To create and configure an C<GeoMatchSet>, perform the following steps:
3581  
3582 =over
3583  
3584 =item 1.
3585  
3586 Submit a CreateGeoMatchSet request.
3587  
3588 =item 2.
3589  
3590 Use GetChangeToken to get the change token that you provide in the
3591 C<ChangeToken> parameter of an UpdateGeoMatchSet request.
3592  
3593 =item 3.
3594  
3595 Submit an C<UpdateGeoMatchSet> request to specify the country that you
3596 want AWS WAF to watch for.
3597  
3598 =back
3599  
3600 When you update an C<GeoMatchSet>, you specify the country that you
3601 want to add and/or the country that you want to delete. If you want to
3602 change a country, you delete the existing country and add the new one.
3603  
3604 For more information about how to use the AWS WAF API to allow or block
3605 HTTP requests, see the AWS WAF Developer Guide
3606 (https://docs.aws.amazon.com/waf/latest/developerguide/).
3607  
3608  
3609 =head2 UpdateIPSet
3610  
3611 =over
3612  
3613 =item ChangeToken => Str
3614  
3615 =item IPSetId => Str
3616  
3617 =item Updates => ArrayRef[L<Paws::WAFRegional::IPSetUpdate>]
3618  
3619  
3620 =back
3621  
3622 Each argument is described in detail in: L<Paws::WAFRegional::UpdateIPSet>
3623  
3624 Returns: a L<Paws::WAFRegional::UpdateIPSetResponse> instance
3625  
3626 This is B<AWS WAF Classic> documentation. For more information, see AWS
3627 WAF Classic
3628 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3629 in the developer guide.
3630  
3631 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3632 AWS WAF Developer Guide
3633 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3634 With the latest version, AWS WAF has a single set of endpoints for
3635 regional and global use.
3636  
3637 Inserts or deletes IPSetDescriptor objects in an C<IPSet>. For each
3638 C<IPSetDescriptor> object, you specify the following values:
3639  
3640 =over
3641  
3642 =item *
3643  
3644 Whether to insert or delete the object from the array. If you want to
3645 change an C<IPSetDescriptor> object, you delete the existing object and
3646 add a new one.
3647  
3648 =item *
3649  
3650 The IP address version, C<IPv4> or C<IPv6>.
3651  
3652 =item *
3653  
3654 The IP address in CIDR notation, for example, C<192.0.2.0/24> (for the
3655 range of IP addresses from C<192.0.2.0> to C<192.0.2.255>) or
3656 C<192.0.2.44/32> (for the individual IP address C<192.0.2.44>).
3657  
3658 =back
3659  
3660 AWS WAF supports IPv4 address ranges: /8 and any range between /16
3661 through /32. AWS WAF supports IPv6 address ranges: /24, /32, /48, /56,
3662 /64, and /128. For more information about CIDR notation, see the
3663 Wikipedia entry Classless Inter-Domain Routing
3664 (https://en.wikipedia.org/wiki/Classless_Inter-Domain_Routing).
3665  
3666 IPv6 addresses can be represented using any of the following formats:
3667  
3668 =over
3669  
3670 =item *
3671  
3672 1111:0000:0000:0000:0000:0000:0000:0111/128
3673  
3674 =item *
3675  
3676 1111:0:0:0:0:0:0:0111/128
3677  
3678 =item *
3679  
3680 1111::0111/128
3681  
3682 =item *
3683  
3684 1111::111/128
3685  
3686 =back
3687  
3688 You use an C<IPSet> to specify which web requests you want to allow or
3689 block based on the IP addresses that the requests originated from. For
3690 example, if you're receiving a lot of requests from one or a small
3691 number of IP addresses and you want to block the requests, you can
3692 create an C<IPSet> that specifies those IP addresses, and then
3693 configure AWS WAF to block the requests.
3694  
3695 To create and configure an C<IPSet>, perform the following steps:
3696  
3697 =over
3698  
3699 =item 1.
3700  
3701 Submit a CreateIPSet request.
3702  
3703 =item 2.
3704  
3705 Use GetChangeToken to get the change token that you provide in the
3706 C<ChangeToken> parameter of an UpdateIPSet request.
3707  
3708 =item 3.
3709  
3710 Submit an C<UpdateIPSet> request to specify the IP addresses that you
3711 want AWS WAF to watch for.
3712  
3713 =back
3714  
3715 When you update an C<IPSet>, you specify the IP addresses that you want
3716 to add and/or the IP addresses that you want to delete. If you want to
3717 change an IP address, you delete the existing IP address and add the
3718 new one.
3719  
3720 You can insert a maximum of 1000 addresses in a single request.
3721  
3722 For more information about how to use the AWS WAF API to allow or block
3723 HTTP requests, see the AWS WAF Developer Guide
3724 (https://docs.aws.amazon.com/waf/latest/developerguide/).
3725  
3726  
3727 =head2 UpdateRateBasedRule
3728  
3729 =over
3730  
3731 =item ChangeToken => Str
3732  
3733 =item RateLimit => Int
3734  
3735 =item RuleId => Str
3736  
3737 =item Updates => ArrayRef[L<Paws::WAFRegional::RuleUpdate>]
3738  
3739  
3740 =back
3741  
3742 Each argument is described in detail in: L<Paws::WAFRegional::UpdateRateBasedRule>
3743  
3744 Returns: a L<Paws::WAFRegional::UpdateRateBasedRuleResponse> instance
3745  
3746 This is B<AWS WAF Classic> documentation. For more information, see AWS
3747 WAF Classic
3748 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3749 in the developer guide.
3750  
3751 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3752 AWS WAF Developer Guide
3753 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3754 With the latest version, AWS WAF has a single set of endpoints for
3755 regional and global use.
3756  
3757 Inserts or deletes Predicate objects in a rule and updates the
3758 C<RateLimit> in the rule.
3759  
3760 Each C<Predicate> object identifies a predicate, such as a ByteMatchSet
3761 or an IPSet, that specifies the web requests that you want to block or
3762 count. The C<RateLimit> specifies the number of requests every five
3763 minutes that triggers the rule.
3764  
3765 If you add more than one predicate to a C<RateBasedRule>, a request
3766 must match all the predicates and exceed the C<RateLimit> to be counted
3767 or blocked. For example, suppose you add the following to a
3768 C<RateBasedRule>:
3769  
3770 =over
3771  
3772 =item *
3773  
3774 An C<IPSet> that matches the IP address C<192.0.2.44/32>
3775  
3776 =item *
3777  
3778 A C<ByteMatchSet> that matches C<BadBot> in the C<User-Agent> header
3779  
3780 =back
3781  
3782 Further, you specify a C<RateLimit> of 1,000.
3783  
3784 You then add the C<RateBasedRule> to a C<WebACL> and specify that you
3785 want to block requests that satisfy the rule. For a request to be
3786 blocked, it must come from the IP address 192.0.2.44 I<and> the
3787 C<User-Agent> header in the request must contain the value C<BadBot>.
3788 Further, requests that match these two conditions much be received at a
3789 rate of more than 1,000 every five minutes. If the rate drops below
3790 this limit, AWS WAF no longer blocks the requests.
3791  
3792 As a second example, suppose you want to limit requests to a particular
3793 page on your site. To do this, you could add the following to a
3794 C<RateBasedRule>:
3795  
3796 =over
3797  
3798 =item *
3799  
3800 A C<ByteMatchSet> with C<FieldToMatch> of C<URI>
3801  
3802 =item *
3803  
3804 A C<PositionalConstraint> of C<STARTS_WITH>
3805  
3806 =item *
3807  
3808 A C<TargetString> of C<login>
3809  
3810 =back
3811  
3812 Further, you specify a C<RateLimit> of 1,000.
3813  
3814 By adding this C<RateBasedRule> to a C<WebACL>, you could limit
3815 requests to your login page without affecting the rest of your site.
3816  
3817  
3818 =head2 UpdateRegexMatchSet
3819  
3820 =over
3821  
3822 =item ChangeToken => Str
3823  
3824 =item RegexMatchSetId => Str
3825  
3826 =item Updates => ArrayRef[L<Paws::WAFRegional::RegexMatchSetUpdate>]
3827  
3828  
3829 =back
3830  
3831 Each argument is described in detail in: L<Paws::WAFRegional::UpdateRegexMatchSet>
3832  
3833 Returns: a L<Paws::WAFRegional::UpdateRegexMatchSetResponse> instance
3834  
3835 This is B<AWS WAF Classic> documentation. For more information, see AWS
3836 WAF Classic
3837 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3838 in the developer guide.
3839  
3840 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3841 AWS WAF Developer Guide
3842 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3843 With the latest version, AWS WAF has a single set of endpoints for
3844 regional and global use.
3845  
3846 Inserts or deletes RegexMatchTuple objects (filters) in a
3847 RegexMatchSet. For each C<RegexMatchSetUpdate> object, you specify the
3848 following values:
3849  
3850 =over
3851  
3852 =item *
3853  
3854 Whether to insert or delete the object from the array. If you want to
3855 change a C<RegexMatchSetUpdate> object, you delete the existing object
3856 and add a new one.
3857  
3858 =item *
3859  
3860 The part of a web request that you want AWS WAF to inspectupdate, such
3861 as a query string or the value of the C<User-Agent> header.
3862  
3863 =item *
3864  
3865 The identifier of the pattern (a regular expression) that you want AWS
3866 WAF to look for. For more information, see RegexPatternSet.
3867  
3868 =item *
3869  
3870 Whether to perform any conversions on the request, such as converting
3871 it to lowercase, before inspecting it for the specified string.
3872  
3873 =back
3874  
3875 For example, you can create a C<RegexPatternSet> that matches any
3876 requests with C<User-Agent> headers that contain the string
3877 C<B[a@]dB[o0]t>. You can then configure AWS WAF to reject those
3878 requests.
3879  
3880 To create and configure a C<RegexMatchSet>, perform the following
3881 steps:
3882  
3883 =over
3884  
3885 =item 1.
3886  
3887 Create a C<RegexMatchSet.> For more information, see
3888 CreateRegexMatchSet.
3889  
3890 =item 2.
3891  
3892 Use GetChangeToken to get the change token that you provide in the
3893 C<ChangeToken> parameter of an C<UpdateRegexMatchSet> request.
3894  
3895 =item 3.
3896  
3897 Submit an C<UpdateRegexMatchSet> request to specify the part of the
3898 request that you want AWS WAF to inspect (for example, the header or
3899 the URI) and the identifier of the C<RegexPatternSet> that contain the
3900 regular expression patters you want AWS WAF to watch for.
3901  
3902 =back
3903  
3904 For more information about how to use the AWS WAF API to allow or block
3905 HTTP requests, see the AWS WAF Developer Guide
3906 (https://docs.aws.amazon.com/waf/latest/developerguide/).
3907  
3908  
3909 =head2 UpdateRegexPatternSet
3910  
3911 =over
3912  
3913 =item ChangeToken => Str
3914  
3915 =item RegexPatternSetId => Str
3916  
3917 =item Updates => ArrayRef[L<Paws::WAFRegional::RegexPatternSetUpdate>]
3918  
3919  
3920 =back
3921  
3922 Each argument is described in detail in: L<Paws::WAFRegional::UpdateRegexPatternSet>
3923  
3924 Returns: a L<Paws::WAFRegional::UpdateRegexPatternSetResponse> instance
3925  
3926 This is B<AWS WAF Classic> documentation. For more information, see AWS
3927 WAF Classic
3928 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
3929 in the developer guide.
3930  
3931 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
3932 AWS WAF Developer Guide
3933 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
3934 With the latest version, AWS WAF has a single set of endpoints for
3935 regional and global use.
3936  
3937 Inserts or deletes C<RegexPatternString> objects in a RegexPatternSet.
3938 For each C<RegexPatternString> object, you specify the following
3939 values:
3940  
3941 =over
3942  
3943 =item *
3944  
3945 Whether to insert or delete the C<RegexPatternString>.
3946  
3947 =item *
3948  
3949 The regular expression pattern that you want to insert or delete. For
3950 more information, see RegexPatternSet.
3951  
3952 =back
3953  
3954 For example, you can create a C<RegexPatternString> such as
3955 C<B[a@]dB[o0]t>. AWS WAF will match this C<RegexPatternString> to:
3956  
3957 =over
3958  
3959 =item *
3960  
3961 BadBot
3962  
3963 =item *
3964  
3965 BadB0t
3966  
3967 =item *
3968  
3969 B@dBot
3970  
3971 =item *
3972  
3973 B@dB0t
3974  
3975 =back
3976  
3977 To create and configure a C<RegexPatternSet>, perform the following
3978 steps:
3979  
3980 =over
3981  
3982 =item 1.
3983  
3984 Create a C<RegexPatternSet.> For more information, see
3985 CreateRegexPatternSet.
3986  
3987 =item 2.
3988  
3989 Use GetChangeToken to get the change token that you provide in the
3990 C<ChangeToken> parameter of an C<UpdateRegexPatternSet> request.
3991  
3992 =item 3.
3993  
3994 Submit an C<UpdateRegexPatternSet> request to specify the regular
3995 expression pattern that you want AWS WAF to watch for.
3996  
3997 =back
3998  
3999 For more information about how to use the AWS WAF API to allow or block
4000 HTTP requests, see the AWS WAF Developer Guide
4001 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4002  
4003  
4004 =head2 UpdateRule
4005  
4006 =over
4007  
4008 =item ChangeToken => Str
4009  
4010 =item RuleId => Str
4011  
4012 =item Updates => ArrayRef[L<Paws::WAFRegional::RuleUpdate>]
4013  
4014  
4015 =back
4016  
4017 Each argument is described in detail in: L<Paws::WAFRegional::UpdateRule>
4018  
4019 Returns: a L<Paws::WAFRegional::UpdateRuleResponse> instance
4020  
4021 This is B<AWS WAF Classic> documentation. For more information, see AWS
4022 WAF Classic
4023 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4024 in the developer guide.
4025  
4026 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4027 AWS WAF Developer Guide
4028 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4029 With the latest version, AWS WAF has a single set of endpoints for
4030 regional and global use.
4031  
4032 Inserts or deletes Predicate objects in a C<Rule>. Each C<Predicate>
4033 object identifies a predicate, such as a ByteMatchSet or an IPSet, that
4034 specifies the web requests that you want to allow, block, or count. If
4035 you add more than one predicate to a C<Rule>, a request must match all
4036 of the specifications to be allowed, blocked, or counted. For example,
4037 suppose that you add the following to a C<Rule>:
4038  
4039 =over
4040  
4041 =item *
4042  
4043 A C<ByteMatchSet> that matches the value C<BadBot> in the C<User-Agent>
4044 header
4045  
4046 =item *
4047  
4048 An C<IPSet> that matches the IP address C<192.0.2.44>
4049  
4050 =back
4051  
4052 You then add the C<Rule> to a C<WebACL> and specify that you want to
4053 block requests that satisfy the C<Rule>. For a request to be blocked,
4054 the C<User-Agent> header in the request must contain the value
4055 C<BadBot> I<and> the request must originate from the IP address
4056 192.0.2.44.
4057  
4058 To create and configure a C<Rule>, perform the following steps:
4059  
4060 =over
4061  
4062 =item 1.
4063  
4064 Create and update the predicates that you want to include in the
4065 C<Rule>.
4066  
4067 =item 2.
4068  
4069 Create the C<Rule>. See CreateRule.
4070  
4071 =item 3.
4072  
4073 Use C<GetChangeToken> to get the change token that you provide in the
4074 C<ChangeToken> parameter of an UpdateRule request.
4075  
4076 =item 4.
4077  
4078 Submit an C<UpdateRule> request to add predicates to the C<Rule>.
4079  
4080 =item 5.
4081  
4082 Create and update a C<WebACL> that contains the C<Rule>. See
4083 CreateWebACL.
4084  
4085 =back
4086  
4087 If you want to replace one C<ByteMatchSet> or C<IPSet> with another,
4088 you delete the existing one and add the new one.
4089  
4090 For more information about how to use the AWS WAF API to allow or block
4091 HTTP requests, see the AWS WAF Developer Guide
4092 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4093  
4094  
4095 =head2 UpdateRuleGroup
4096  
4097 =over
4098  
4099 =item ChangeToken => Str
4100  
4101 =item RuleGroupId => Str
4102  
4103 =item Updates => ArrayRef[L<Paws::WAFRegional::RuleGroupUpdate>]
4104  
4105  
4106 =back
4107  
4108 Each argument is described in detail in: L<Paws::WAFRegional::UpdateRuleGroup>
4109  
4110 Returns: a L<Paws::WAFRegional::UpdateRuleGroupResponse> instance
4111  
4112 This is B<AWS WAF Classic> documentation. For more information, see AWS
4113 WAF Classic
4114 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4115 in the developer guide.
4116  
4117 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4118 AWS WAF Developer Guide
4119 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4120 With the latest version, AWS WAF has a single set of endpoints for
4121 regional and global use.
4122  
4123 Inserts or deletes ActivatedRule objects in a C<RuleGroup>.
4124  
4125 You can only insert C<REGULAR> rules into a rule group.
4126  
4127 You can have a maximum of ten rules per rule group.
4128  
4129 To create and configure a C<RuleGroup>, perform the following steps:
4130  
4131 =over
4132  
4133 =item 1.
4134  
4135 Create and update the C<Rules> that you want to include in the
4136 C<RuleGroup>. See CreateRule.
4137  
4138 =item 2.
4139  
4140 Use C<GetChangeToken> to get the change token that you provide in the
4141 C<ChangeToken> parameter of an UpdateRuleGroup request.
4142  
4143 =item 3.
4144  
4145 Submit an C<UpdateRuleGroup> request to add C<Rules> to the
4146 C<RuleGroup>.
4147  
4148 =item 4.
4149  
4150 Create and update a C<WebACL> that contains the C<RuleGroup>. See
4151 CreateWebACL.
4152  
4153 =back
4154  
4155 If you want to replace one C<Rule> with another, you delete the
4156 existing one and add the new one.
4157  
4158 For more information about how to use the AWS WAF API to allow or block
4159 HTTP requests, see the AWS WAF Developer Guide
4160 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4161  
4162  
4163 =head2 UpdateSizeConstraintSet
4164  
4165 =over
4166  
4167 =item ChangeToken => Str
4168  
4169 =item SizeConstraintSetId => Str
4170  
4171 =item Updates => ArrayRef[L<Paws::WAFRegional::SizeConstraintSetUpdate>]
4172  
4173  
4174 =back
4175  
4176 Each argument is described in detail in: L<Paws::WAFRegional::UpdateSizeConstraintSet>
4177  
4178 Returns: a L<Paws::WAFRegional::UpdateSizeConstraintSetResponse> instance
4179  
4180 This is B<AWS WAF Classic> documentation. For more information, see AWS
4181 WAF Classic
4182 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4183 in the developer guide.
4184  
4185 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4186 AWS WAF Developer Guide
4187 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4188 With the latest version, AWS WAF has a single set of endpoints for
4189 regional and global use.
4190  
4191 Inserts or deletes SizeConstraint objects (filters) in a
4192 SizeConstraintSet. For each C<SizeConstraint> object, you specify the
4193 following values:
4194  
4195 =over
4196  
4197 =item *
4198  
4199 Whether to insert or delete the object from the array. If you want to
4200 change a C<SizeConstraintSetUpdate> object, you delete the existing
4201 object and add a new one.
4202  
4203 =item *
4204  
4205 The part of a web request that you want AWS WAF to evaluate, such as
4206 the length of a query string or the length of the C<User-Agent> header.
4207  
4208 =item *
4209  
4210 Whether to perform any transformations on the request, such as
4211 converting it to lowercase, before checking its length. Note that
4212 transformations of the request body are not supported because the AWS
4213 resource forwards only the first C<8192> bytes of your request to AWS
4214 WAF.
4215  
4216 You can only specify a single type of TextTransformation.
4217  
4218 =item *
4219  
4220 A C<ComparisonOperator> used for evaluating the selected part of the
4221 request against the specified C<Size>, such as equals, greater than,
4222 less than, and so on.
4223  
4224 =item *
4225  
4226 The length, in bytes, that you want AWS WAF to watch for in selected
4227 part of the request. The length is computed after applying the
4228 transformation.
4229  
4230 =back
4231  
4232 For example, you can add a C<SizeConstraintSetUpdate> object that
4233 matches web requests in which the length of the C<User-Agent> header is
4234 greater than 100 bytes. You can then configure AWS WAF to block those
4235 requests.
4236  
4237 To create and configure a C<SizeConstraintSet>, perform the following
4238 steps:
4239  
4240 =over
4241  
4242 =item 1.
4243  
4244 Create a C<SizeConstraintSet.> For more information, see
4245 CreateSizeConstraintSet.
4246  
4247 =item 2.
4248  
4249 Use GetChangeToken to get the change token that you provide in the
4250 C<ChangeToken> parameter of an C<UpdateSizeConstraintSet> request.
4251  
4252 =item 3.
4253  
4254 Submit an C<UpdateSizeConstraintSet> request to specify the part of the
4255 request that you want AWS WAF to inspect (for example, the header or
4256 the URI) and the value that you want AWS WAF to watch for.
4257  
4258 =back
4259  
4260 For more information about how to use the AWS WAF API to allow or block
4261 HTTP requests, see the AWS WAF Developer Guide
4262 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4263  
4264  
4265 =head2 UpdateSqlInjectionMatchSet
4266  
4267 =over
4268  
4269 =item ChangeToken => Str
4270  
4271 =item SqlInjectionMatchSetId => Str
4272  
4273 =item Updates => ArrayRef[L<Paws::WAFRegional::SqlInjectionMatchSetUpdate>]
4274  
4275  
4276 =back
4277  
4278 Each argument is described in detail in: L<Paws::WAFRegional::UpdateSqlInjectionMatchSet>
4279  
4280 Returns: a L<Paws::WAFRegional::UpdateSqlInjectionMatchSetResponse> instance
4281  
4282 This is B<AWS WAF Classic> documentation. For more information, see AWS
4283 WAF Classic
4284 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4285 in the developer guide.
4286  
4287 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4288 AWS WAF Developer Guide
4289 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4290 With the latest version, AWS WAF has a single set of endpoints for
4291 regional and global use.
4292  
4293 Inserts or deletes SqlInjectionMatchTuple objects (filters) in a
4294 SqlInjectionMatchSet. For each C<SqlInjectionMatchTuple> object, you
4295 specify the following values:
4296  
4297 =over
4298  
4299 =item *
4300  
4301 C<Action>: Whether to insert the object into or delete the object from
4302 the array. To change a C<SqlInjectionMatchTuple>, you delete the
4303 existing object and add a new one.
4304  
4305 =item *
4306  
4307 C<FieldToMatch>: The part of web requests that you want AWS WAF to
4308 inspect and, if you want AWS WAF to inspect a header or custom query
4309 parameter, the name of the header or parameter.
4310  
4311 =item *
4312  
4313 C<TextTransformation>: Which text transformation, if any, to perform on
4314 the web request before inspecting the request for snippets of malicious
4315 SQL code.
4316  
4317 You can only specify a single type of TextTransformation.
4318  
4319 =back
4320  
4321 You use C<SqlInjectionMatchSet> objects to specify which CloudFront
4322 requests that you want to allow, block, or count. For example, if
4323 you're receiving requests that contain snippets of SQL code in the
4324 query string and you want to block the requests, you can create a
4325 C<SqlInjectionMatchSet> with the applicable settings, and then
4326 configure AWS WAF to block the requests.
4327  
4328 To create and configure a C<SqlInjectionMatchSet>, perform the
4329 following steps:
4330  
4331 =over
4332  
4333 =item 1.
4334  
4335 Submit a CreateSqlInjectionMatchSet request.
4336  
4337 =item 2.
4338  
4339 Use GetChangeToken to get the change token that you provide in the
4340 C<ChangeToken> parameter of an UpdateIPSet request.
4341  
4342 =item 3.
4343  
4344 Submit an C<UpdateSqlInjectionMatchSet> request to specify the parts of
4345 web requests that you want AWS WAF to inspect for snippets of SQL code.
4346  
4347 =back
4348  
4349 For more information about how to use the AWS WAF API to allow or block
4350 HTTP requests, see the AWS WAF Developer Guide
4351 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4352  
4353  
4354 =head2 UpdateWebACL
4355  
4356 =over
4357  
4358 =item ChangeToken => Str
4359  
4360 =item WebACLId => Str
4361  
4362 =item [DefaultAction => L<Paws::WAFRegional::WafAction>]
4363  
4364 =item [Updates => ArrayRef[L<Paws::WAFRegional::WebACLUpdate>]]
4365  
4366  
4367 =back
4368  
4369 Each argument is described in detail in: L<Paws::WAFRegional::UpdateWebACL>
4370  
4371 Returns: a L<Paws::WAFRegional::UpdateWebACLResponse> instance
4372  
4373 This is B<AWS WAF Classic> documentation. For more information, see AWS
4374 WAF Classic
4375 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4376 in the developer guide.
4377  
4378 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4379 AWS WAF Developer Guide
4380 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4381 With the latest version, AWS WAF has a single set of endpoints for
4382 regional and global use.
4383  
4384 Inserts or deletes ActivatedRule objects in a C<WebACL>. Each C<Rule>
4385 identifies web requests that you want to allow, block, or count. When
4386 you update a C<WebACL>, you specify the following values:
4387  
4388 =over
4389  
4390 =item *
4391  
4392 A default action for the C<WebACL>, either C<ALLOW> or C<BLOCK>. AWS
4393 WAF performs the default action if a request doesn't match the criteria
4394 in any of the C<Rules> in a C<WebACL>.
4395  
4396 =item *
4397  
4398 The C<Rules> that you want to add or delete. If you want to replace one
4399 C<Rule> with another, you delete the existing C<Rule> and add the new
4400 one.
4401  
4402 =item *
4403  
4404 For each C<Rule>, whether you want AWS WAF to allow requests, block
4405 requests, or count requests that match the conditions in the C<Rule>.
4406  
4407 =item *
4408  
4409 The order in which you want AWS WAF to evaluate the C<Rules> in a
4410 C<WebACL>. If you add more than one C<Rule> to a C<WebACL>, AWS WAF
4411 evaluates each request against the C<Rules> in order based on the value
4412 of C<Priority>. (The C<Rule> that has the lowest value for C<Priority>
4413 is evaluated first.) When a web request matches all the predicates
4414 (such as C<ByteMatchSets> and C<IPSets>) in a C<Rule>, AWS WAF
4415 immediately takes the corresponding action, allow or block, and doesn't
4416 evaluate the request against the remaining C<Rules> in the C<WebACL>,
4417 if any.
4418  
4419 =back
4420  
4421 To create and configure a C<WebACL>, perform the following steps:
4422  
4423 =over
4424  
4425 =item 1.
4426  
4427 Create and update the predicates that you want to include in C<Rules>.
4428 For more information, see CreateByteMatchSet, UpdateByteMatchSet,
4429 CreateIPSet, UpdateIPSet, CreateSqlInjectionMatchSet, and
4430 UpdateSqlInjectionMatchSet.
4431  
4432 =item 2.
4433  
4434 Create and update the C<Rules> that you want to include in the
4435 C<WebACL>. For more information, see CreateRule and UpdateRule.
4436  
4437 =item 3.
4438  
4439 Create a C<WebACL>. See CreateWebACL.
4440  
4441 =item 4.
4442  
4443 Use C<GetChangeToken> to get the change token that you provide in the
4444 C<ChangeToken> parameter of an UpdateWebACL request.
4445  
4446 =item 5.
4447  
4448 Submit an C<UpdateWebACL> request to specify the C<Rules> that you want
4449 to include in the C<WebACL>, to specify the default action, and to
4450 associate the C<WebACL> with a CloudFront distribution.
4451  
4452 The C<ActivatedRule> can be a rule group. If you specify a rule group
4453 as your C<ActivatedRule> , you can exclude specific rules from that
4454 rule group.
4455  
4456 If you already have a rule group associated with a web ACL and want to
4457 submit an C<UpdateWebACL> request to exclude certain rules from that
4458 rule group, you must first remove the rule group from the web ACL, the
4459 re-insert it again, specifying the excluded rules. For details, see
4460 ActivatedRule$ExcludedRules .
4461  
4462 =back
4463  
4464 Be aware that if you try to add a RATE_BASED rule to a web ACL without
4465 setting the rule type when first creating the rule, the UpdateWebACL
4466 request will fail because the request tries to add a REGULAR rule (the
4467 default rule type) with the specified ID, which does not exist.
4468  
4469 For more information about how to use the AWS WAF API to allow or block
4470 HTTP requests, see the AWS WAF Developer Guide
4471 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4472  
4473  
4474 =head2 UpdateXssMatchSet
4475  
4476 =over
4477  
4478 =item ChangeToken => Str
4479  
4480 =item Updates => ArrayRef[L<Paws::WAFRegional::XssMatchSetUpdate>]
4481  
4482 =item XssMatchSetId => Str
4483  
4484  
4485 =back
4486  
4487 Each argument is described in detail in: L<Paws::WAFRegional::UpdateXssMatchSet>
4488  
4489 Returns: a L<Paws::WAFRegional::UpdateXssMatchSetResponse> instance
4490  
4491 This is B<AWS WAF Classic> documentation. For more information, see AWS
4492 WAF Classic
4493 (https://docs.aws.amazon.com/waf/latest/developerguide/classic-waf-chapter.html)
4494 in the developer guide.
4495  
4496 B<For the latest version of AWS WAF>, use the AWS WAFV2 API and see the
4497 AWS WAF Developer Guide
4498 (https://docs.aws.amazon.com/waf/latest/developerguide/waf-chapter.html).
4499 With the latest version, AWS WAF has a single set of endpoints for
4500 regional and global use.
4501  
4502 Inserts or deletes XssMatchTuple objects (filters) in an XssMatchSet.
4503 For each C<XssMatchTuple> object, you specify the following values:
4504  
4505 =over
4506  
4507 =item *
4508  
4509 C<Action>: Whether to insert the object into or delete the object from
4510 the array. To change an C<XssMatchTuple>, you delete the existing
4511 object and add a new one.
4512  
4513 =item *
4514  
4515 C<FieldToMatch>: The part of web requests that you want AWS WAF to
4516 inspect and, if you want AWS WAF to inspect a header or custom query
4517 parameter, the name of the header or parameter.
4518  
4519 =item *
4520  
4521 C<TextTransformation>: Which text transformation, if any, to perform on
4522 the web request before inspecting the request for cross-site scripting
4523 attacks.
4524  
4525 You can only specify a single type of TextTransformation.
4526  
4527 =back
4528  
4529 You use C<XssMatchSet> objects to specify which CloudFront requests
4530 that you want to allow, block, or count. For example, if you're
4531 receiving requests that contain cross-site scripting attacks in the
4532 request body and you want to block the requests, you can create an
4533 C<XssMatchSet> with the applicable settings, and then configure AWS WAF
4534 to block the requests.
4535  
4536 To create and configure an C<XssMatchSet>, perform the following steps:
4537  
4538 =over
4539  
4540 =item 1.
4541  
4542 Submit a CreateXssMatchSet request.
4543  
4544 =item 2.
4545  
4546 Use GetChangeToken to get the change token that you provide in the
4547 C<ChangeToken> parameter of an UpdateIPSet request.
4548  
4549 =item 3.
4550  
4551 Submit an C<UpdateXssMatchSet> request to specify the parts of web
4552 requests that you want AWS WAF to inspect for cross-site scripting
4553 attacks.
4554  
4555 =back
4556  
4557 For more information about how to use the AWS WAF API to allow or block
4558 HTTP requests, see the AWS WAF Developer Guide
4559 (https://docs.aws.amazon.com/waf/latest/developerguide/).
4560  
4561  
4562  
4563  
4564 =head1 PAGINATORS
4565  
4566 Paginator methods are helpers that repetively call methods that return partial results
4567  
4568  
4569  
4570  
4571 =head1 SEE ALSO
4572  
4573 This service class forms part of L<Paws>
4574  
4575 =head1 BUGS and CONTRIBUTIONS
4576  
4577 The source code is located here: L<https://github.com/pplu/aws-sdk-perl>
4578  
4579 Please report bugs to: L<https://github.com/pplu/aws-sdk-perl/issues>
4580  
4581 =cut
4582