File Coverage

blib/lib/Paws/Route53Domains.pm
Criterion Covered Total %
statement 13 119 10.9
branch 0 8 0.0
condition n/a
subroutine 5 33 15.1
pod 26 31 83.8
total 44 191 23.0


line stmt bran cond sub pod time code
1             package Paws::Route53Domains;
2 1     1   10420 use Moose;
  1     1   4  
  1         10  
  1         520  
  1         2  
  1         8  
3 2     2 0 8 sub service { 'route53domains' }
4 0     0 0 0 sub version { '2014-05-15' }
5 0     0 0 0 sub target_prefix { 'Route53Domains_v20140515' }
6 0     0 0 0 sub json_version { "1.1" }
7             has max_attempts => (is => 'ro', isa => 'Int', default => 5);
8             has retry => (is => 'ro', isa => 'HashRef', default => sub {
9             { base => 'rand', type => 'exponential', growth_factor => 2 }
10             });
11             has retriables => (is => 'ro', isa => 'ArrayRef', default => sub { [
12             ] });
13              
14             with 'Paws::API::Caller', 'Paws::API::EndpointResolver', 'Paws::Net::V4Signature', 'Paws::Net::JsonCaller', 'Paws::Net::JsonResponse';
15              
16            
17             sub CheckDomainAvailability {
18 1     1 1 301 my $self = shift;
19 1         6 my $call_object = $self->new_with_coercions('Paws::Route53Domains::CheckDomainAvailability', @_);
20 1         575 return $self->caller->do_call($self, $call_object);
21             }
22             sub CheckDomainTransferability {
23 0     0 1 0 my $self = shift;
24 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::CheckDomainTransferability', @_);
25 0         0 return $self->caller->do_call($self, $call_object);
26             }
27             sub DeleteTagsForDomain {
28 0     0 1 0 my $self = shift;
29 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::DeleteTagsForDomain', @_);
30 0         0 return $self->caller->do_call($self, $call_object);
31             }
32             sub DisableDomainAutoRenew {
33 0     0 1 0 my $self = shift;
34 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::DisableDomainAutoRenew', @_);
35 0         0 return $self->caller->do_call($self, $call_object);
36             }
37             sub DisableDomainTransferLock {
38 0     0 1 0 my $self = shift;
39 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::DisableDomainTransferLock', @_);
40 0         0 return $self->caller->do_call($self, $call_object);
41             }
42             sub EnableDomainAutoRenew {
43 0     0 1 0 my $self = shift;
44 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::EnableDomainAutoRenew', @_);
45 0         0 return $self->caller->do_call($self, $call_object);
46             }
47             sub EnableDomainTransferLock {
48 0     0 1 0 my $self = shift;
49 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::EnableDomainTransferLock', @_);
50 0         0 return $self->caller->do_call($self, $call_object);
51             }
52             sub GetContactReachabilityStatus {
53 0     0 1 0 my $self = shift;
54 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::GetContactReachabilityStatus', @_);
55 0         0 return $self->caller->do_call($self, $call_object);
56             }
57             sub GetDomainDetail {
58 0     0 1 0 my $self = shift;
59 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::GetDomainDetail', @_);
60 0         0 return $self->caller->do_call($self, $call_object);
61             }
62             sub GetDomainSuggestions {
63 0     0 1 0 my $self = shift;
64 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::GetDomainSuggestions', @_);
65 0         0 return $self->caller->do_call($self, $call_object);
66             }
67             sub GetOperationDetail {
68 0     0 1 0 my $self = shift;
69 0         0 my $call_object = $self->new_with_coercions('Paws::Route53Domains::GetOperationDetail', @_);
70 0         0 return $self->caller->do_call($self, $call_object);
71             }
72             sub ListDomains {
73 1     1 1 226 my $self = shift;
74 1         8 my $call_object = $self->new_with_coercions('Paws::Route53Domains::ListDomains', @_);
75 1         405 return $self->caller->do_call($self, $call_object);
76             }
77             sub ListOperations {
78 0     0 1   my $self = shift;
79 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::ListOperations', @_);
80 0           return $self->caller->do_call($self, $call_object);
81             }
82             sub ListTagsForDomain {
83 0     0 1   my $self = shift;
84 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::ListTagsForDomain', @_);
85 0           return $self->caller->do_call($self, $call_object);
86             }
87             sub RegisterDomain {
88 0     0 1   my $self = shift;
89 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::RegisterDomain', @_);
90 0           return $self->caller->do_call($self, $call_object);
91             }
92             sub RenewDomain {
93 0     0 1   my $self = shift;
94 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::RenewDomain', @_);
95 0           return $self->caller->do_call($self, $call_object);
96             }
97             sub ResendContactReachabilityEmail {
98 0     0 1   my $self = shift;
99 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::ResendContactReachabilityEmail', @_);
100 0           return $self->caller->do_call($self, $call_object);
101             }
102             sub RetrieveDomainAuthCode {
103 0     0 1   my $self = shift;
104 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::RetrieveDomainAuthCode', @_);
105 0           return $self->caller->do_call($self, $call_object);
106             }
107             sub TransferDomain {
108 0     0 1   my $self = shift;
109 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::TransferDomain', @_);
110 0           return $self->caller->do_call($self, $call_object);
111             }
112             sub UpdateDomainContact {
113 0     0 1   my $self = shift;
114 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::UpdateDomainContact', @_);
115 0           return $self->caller->do_call($self, $call_object);
116             }
117             sub UpdateDomainContactPrivacy {
118 0     0 1   my $self = shift;
119 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::UpdateDomainContactPrivacy', @_);
120 0           return $self->caller->do_call($self, $call_object);
121             }
122             sub UpdateDomainNameservers {
123 0     0 1   my $self = shift;
124 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::UpdateDomainNameservers', @_);
125 0           return $self->caller->do_call($self, $call_object);
126             }
127             sub UpdateTagsForDomain {
128 0     0 1   my $self = shift;
129 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::UpdateTagsForDomain', @_);
130 0           return $self->caller->do_call($self, $call_object);
131             }
132             sub ViewBilling {
133 0     0 1   my $self = shift;
134 0           my $call_object = $self->new_with_coercions('Paws::Route53Domains::ViewBilling', @_);
135 0           return $self->caller->do_call($self, $call_object);
136             }
137            
138             sub ListAllDomains {
139 0     0 1   my $self = shift;
140              
141 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
142 0           my $result = $self->ListDomains(@_);
143 0           my $next_result = $result;
144              
145 0 0         if (not defined $callback) {
146 0           while ($next_result->NextPageMarker) {
147 0           $next_result = $self->ListDomains(@_, Marker => $next_result->NextPageMarker);
148 0           push @{ $result->Domains }, @{ $next_result->Domains };
  0            
  0            
149             }
150 0           return $result;
151             } else {
152 0           while ($result->NextPageMarker) {
153 0           $callback->($_ => 'Domains') foreach (@{ $result->Domains });
  0            
154 0           $result = $self->ListDomains(@_, Marker => $result->NextPageMarker);
155             }
156 0           $callback->($_ => 'Domains') foreach (@{ $result->Domains });
  0            
157             }
158              
159             return undef
160 0           }
161             sub ListAllOperations {
162 0     0 1   my $self = shift;
163              
164 0 0         my $callback = shift @_ if (ref($_[0]) eq 'CODE');
165 0           my $result = $self->ListOperations(@_);
166 0           my $next_result = $result;
167              
168 0 0         if (not defined $callback) {
169 0           while ($next_result->NextPageMarker) {
170 0           $next_result = $self->ListOperations(@_, Marker => $next_result->NextPageMarker);
171 0           push @{ $result->Operations }, @{ $next_result->Operations };
  0            
  0            
172             }
173 0           return $result;
174             } else {
175 0           while ($result->NextPageMarker) {
176 0           $callback->($_ => 'Operations') foreach (@{ $result->Operations });
  0            
177 0           $result = $self->ListOperations(@_, Marker => $result->NextPageMarker);
178             }
179 0           $callback->($_ => 'Operations') foreach (@{ $result->Operations });
  0            
180             }
181              
182             return undef
183 0           }
184              
185              
186 0     0 0   sub operations { qw/CheckDomainAvailability CheckDomainTransferability DeleteTagsForDomain DisableDomainAutoRenew DisableDomainTransferLock EnableDomainAutoRenew EnableDomainTransferLock GetContactReachabilityStatus GetDomainDetail GetDomainSuggestions GetOperationDetail ListDomains ListOperations ListTagsForDomain RegisterDomain RenewDomain ResendContactReachabilityEmail RetrieveDomainAuthCode TransferDomain UpdateDomainContact UpdateDomainContactPrivacy UpdateDomainNameservers UpdateTagsForDomain ViewBilling / }
187              
188             1;
189              
190             ### main pod documentation begin ###
191              
192             =head1 NAME
193              
194             Paws::Route53Domains - Perl Interface to AWS Amazon Route 53 Domains
195              
196             =head1 SYNOPSIS
197              
198             use Paws;
199              
200             my $obj = Paws->service('Route53Domains');
201             my $res = $obj->Method(
202             Arg1 => $val1,
203             Arg2 => [ 'V1', 'V2' ],
204             # if Arg3 is an object, the HashRef will be used as arguments to the constructor
205             # of the arguments type
206             Arg3 => { Att1 => 'Val1' },
207             # if Arg4 is an array of objects, the HashRefs will be passed as arguments to
208             # the constructor of the arguments type
209             Arg4 => [ { Att1 => 'Val1' }, { Att1 => 'Val2' } ],
210             );
211              
212             =head1 DESCRIPTION
213              
214             Amazon Route 53 API actions let you register domain names and perform
215             related operations.
216              
217             =head1 METHODS
218              
219             =head2 CheckDomainAvailability(DomainName => Str, [IdnLangCode => Str])
220              
221             Each argument is described in detail in: L<Paws::Route53Domains::CheckDomainAvailability>
222              
223             Returns: a L<Paws::Route53Domains::CheckDomainAvailabilityResponse> instance
224              
225             This operation checks the availability of one domain name. Note that if
226             the availability status of a domain is pending, you must submit another
227             request to determine the availability of the domain name.
228              
229              
230             =head2 CheckDomainTransferability(DomainName => Str, [AuthCode => Str])
231              
232             Each argument is described in detail in: L<Paws::Route53Domains::CheckDomainTransferability>
233              
234             Returns: a L<Paws::Route53Domains::CheckDomainTransferabilityResponse> instance
235              
236             Checks whether a domain name can be transferred to Amazon Route 53.
237              
238              
239             =head2 DeleteTagsForDomain(DomainName => Str, TagsToDelete => ArrayRef[Str|Undef])
240              
241             Each argument is described in detail in: L<Paws::Route53Domains::DeleteTagsForDomain>
242              
243             Returns: a L<Paws::Route53Domains::DeleteTagsForDomainResponse> instance
244              
245             This operation deletes the specified tags for a domain.
246              
247             All tag operations are eventually consistent; subsequent operations
248             might not immediately represent all issued operations.
249              
250              
251             =head2 DisableDomainAutoRenew(DomainName => Str)
252              
253             Each argument is described in detail in: L<Paws::Route53Domains::DisableDomainAutoRenew>
254              
255             Returns: a L<Paws::Route53Domains::DisableDomainAutoRenewResponse> instance
256              
257             This operation disables automatic renewal of domain registration for
258             the specified domain.
259              
260              
261             =head2 DisableDomainTransferLock(DomainName => Str)
262              
263             Each argument is described in detail in: L<Paws::Route53Domains::DisableDomainTransferLock>
264              
265             Returns: a L<Paws::Route53Domains::DisableDomainTransferLockResponse> instance
266              
267             This operation removes the transfer lock on the domain (specifically
268             the C<clientTransferProhibited> status) to allow domain transfers. We
269             recommend you refrain from performing this action unless you intend to
270             transfer the domain to a different registrar. Successful submission
271             returns an operation ID that you can use to track the progress and
272             completion of the action. If the request is not completed successfully,
273             the domain registrant will be notified by email.
274              
275              
276             =head2 EnableDomainAutoRenew(DomainName => Str)
277              
278             Each argument is described in detail in: L<Paws::Route53Domains::EnableDomainAutoRenew>
279              
280             Returns: a L<Paws::Route53Domains::EnableDomainAutoRenewResponse> instance
281              
282             This operation configures Amazon Route 53 to automatically renew the
283             specified domain before the domain registration expires. The cost of
284             renewing your domain registration is billed to your AWS account.
285              
286             The period during which you can renew a domain name varies by TLD. For
287             a list of TLDs and their renewal policies, see "Renewal, restoration,
288             and deletion times" on the website for our registrar partner, Gandi.
289             Route 53 requires that you renew before the end of the renewal period
290             that is listed on the Gandi website so we can complete processing
291             before the deadline.
292              
293              
294             =head2 EnableDomainTransferLock(DomainName => Str)
295              
296             Each argument is described in detail in: L<Paws::Route53Domains::EnableDomainTransferLock>
297              
298             Returns: a L<Paws::Route53Domains::EnableDomainTransferLockResponse> instance
299              
300             This operation sets the transfer lock on the domain (specifically the
301             C<clientTransferProhibited> status) to prevent domain transfers.
302             Successful submission returns an operation ID that you can use to track
303             the progress and completion of the action. If the request is not
304             completed successfully, the domain registrant will be notified by
305             email.
306              
307              
308             =head2 GetContactReachabilityStatus([DomainName => Str])
309              
310             Each argument is described in detail in: L<Paws::Route53Domains::GetContactReachabilityStatus>
311              
312             Returns: a L<Paws::Route53Domains::GetContactReachabilityStatusResponse> instance
313              
314             For operations that require confirmation that the email address for the
315             registrant contact is valid, such as registering a new domain, this
316             operation returns information about whether the registrant contact has
317             responded.
318              
319             If you want us to resend the email, use the
320             C<ResendContactReachabilityEmail> operation.
321              
322              
323             =head2 GetDomainDetail(DomainName => Str)
324              
325             Each argument is described in detail in: L<Paws::Route53Domains::GetDomainDetail>
326              
327             Returns: a L<Paws::Route53Domains::GetDomainDetailResponse> instance
328              
329             This operation returns detailed information about a specified domain
330             that is associated with the current AWS account. Contact information
331             for the domain is also returned as part of the output.
332              
333              
334             =head2 GetDomainSuggestions(DomainName => Str, OnlyAvailable => Bool, SuggestionCount => Int)
335              
336             Each argument is described in detail in: L<Paws::Route53Domains::GetDomainSuggestions>
337              
338             Returns: a L<Paws::Route53Domains::GetDomainSuggestionsResponse> instance
339              
340             The GetDomainSuggestions operation returns a list of suggested domain
341             names given a string, which can either be a domain name or simply a
342             word or phrase (without spaces).
343              
344              
345             =head2 GetOperationDetail(OperationId => Str)
346              
347             Each argument is described in detail in: L<Paws::Route53Domains::GetOperationDetail>
348              
349             Returns: a L<Paws::Route53Domains::GetOperationDetailResponse> instance
350              
351             This operation returns the current status of an operation that is not
352             completed.
353              
354              
355             =head2 ListDomains([Marker => Str, MaxItems => Int])
356              
357             Each argument is described in detail in: L<Paws::Route53Domains::ListDomains>
358              
359             Returns: a L<Paws::Route53Domains::ListDomainsResponse> instance
360              
361             This operation returns all the domain names registered with Amazon
362             Route 53 for the current AWS account.
363              
364              
365             =head2 ListOperations([Marker => Str, MaxItems => Int])
366              
367             Each argument is described in detail in: L<Paws::Route53Domains::ListOperations>
368              
369             Returns: a L<Paws::Route53Domains::ListOperationsResponse> instance
370              
371             This operation returns the operation IDs of operations that are not yet
372             complete.
373              
374              
375             =head2 ListTagsForDomain(DomainName => Str)
376              
377             Each argument is described in detail in: L<Paws::Route53Domains::ListTagsForDomain>
378              
379             Returns: a L<Paws::Route53Domains::ListTagsForDomainResponse> instance
380              
381             This operation returns all of the tags that are associated with the
382             specified domain.
383              
384             All tag operations are eventually consistent; subsequent operations
385             might not immediately represent all issued operations.
386              
387              
388             =head2 RegisterDomain(AdminContact => L<Paws::Route53Domains::ContactDetail>, DomainName => Str, DurationInYears => Int, RegistrantContact => L<Paws::Route53Domains::ContactDetail>, TechContact => L<Paws::Route53Domains::ContactDetail>, [AutoRenew => Bool, IdnLangCode => Str, PrivacyProtectAdminContact => Bool, PrivacyProtectRegistrantContact => Bool, PrivacyProtectTechContact => Bool])
389              
390             Each argument is described in detail in: L<Paws::Route53Domains::RegisterDomain>
391              
392             Returns: a L<Paws::Route53Domains::RegisterDomainResponse> instance
393              
394             This operation registers a domain. Domains are registered by the AWS
395             registrar partner, Gandi. For some top-level domains (TLDs), this
396             operation requires extra parameters.
397              
398             When you register a domain, Amazon Route 53 does the following:
399              
400             =over
401              
402             =item *
403              
404             Creates a Amazon Route 53 hosted zone that has the same name as the
405             domain. Amazon Route 53 assigns four name servers to your hosted zone
406             and automatically updates your domain registration with the names of
407             these name servers.
408              
409             =item *
410              
411             Enables autorenew, so your domain registration will renew automatically
412             each year. We'll notify you in advance of the renewal date so you can
413             choose whether to renew the registration.
414              
415             =item *
416              
417             Optionally enables privacy protection, so WHOIS queries return contact
418             information for our registrar partner, Gandi, instead of the
419             information you entered for registrant, admin, and tech contacts.
420              
421             =item *
422              
423             If registration is successful, returns an operation ID that you can use
424             to track the progress and completion of the action. If the request is
425             not completed successfully, the domain registrant is notified by email.
426              
427             =item *
428              
429             Charges your AWS account an amount based on the top-level domain. For
430             more information, see Amazon Route 53 Pricing.
431              
432             =back
433              
434              
435              
436             =head2 RenewDomain(CurrentExpiryYear => Int, DomainName => Str, [DurationInYears => Int])
437              
438             Each argument is described in detail in: L<Paws::Route53Domains::RenewDomain>
439              
440             Returns: a L<Paws::Route53Domains::RenewDomainResponse> instance
441              
442             This operation renews a domain for the specified number of years. The
443             cost of renewing your domain is billed to your AWS account.
444              
445             We recommend that you renew your domain several weeks before the
446             expiration date. Some TLD registries delete domains before the
447             expiration date if you haven't renewed far enough in advance. For more
448             information about renewing domain registration, see Renewing
449             Registration for a Domain in the Amazon Route 53 Developer Guide.
450              
451              
452             =head2 ResendContactReachabilityEmail([DomainName => Str])
453              
454             Each argument is described in detail in: L<Paws::Route53Domains::ResendContactReachabilityEmail>
455              
456             Returns: a L<Paws::Route53Domains::ResendContactReachabilityEmailResponse> instance
457              
458             For operations that require confirmation that the email address for the
459             registrant contact is valid, such as registering a new domain, this
460             operation resends the confirmation email to the current email address
461             for the registrant contact.
462              
463              
464             =head2 RetrieveDomainAuthCode(DomainName => Str)
465              
466             Each argument is described in detail in: L<Paws::Route53Domains::RetrieveDomainAuthCode>
467              
468             Returns: a L<Paws::Route53Domains::RetrieveDomainAuthCodeResponse> instance
469              
470             This operation returns the AuthCode for the domain. To transfer a
471             domain to another registrar, you provide this value to the new
472             registrar.
473              
474              
475             =head2 TransferDomain(AdminContact => L<Paws::Route53Domains::ContactDetail>, DomainName => Str, DurationInYears => Int, RegistrantContact => L<Paws::Route53Domains::ContactDetail>, TechContact => L<Paws::Route53Domains::ContactDetail>, [AuthCode => Str, AutoRenew => Bool, IdnLangCode => Str, Nameservers => ArrayRef[L<Paws::Route53Domains::Nameserver>], PrivacyProtectAdminContact => Bool, PrivacyProtectRegistrantContact => Bool, PrivacyProtectTechContact => Bool])
476              
477             Each argument is described in detail in: L<Paws::Route53Domains::TransferDomain>
478              
479             Returns: a L<Paws::Route53Domains::TransferDomainResponse> instance
480              
481             This operation transfers a domain from another registrar to Amazon
482             Route 53. When the transfer is complete, the domain is registered with
483             the AWS registrar partner, Gandi.
484              
485             For transfer requirements, a detailed procedure, and information about
486             viewing the status of a domain transfer, see Transferring Registration
487             for a Domain to Amazon Route 53 in the I<Amazon Route 53 Developer
488             Guide>.
489              
490             If the registrar for your domain is also the DNS service provider for
491             the domain, we highly recommend that you consider transferring your DNS
492             service to Amazon Route 53 or to another DNS service provider before
493             you transfer your registration. Some registrars provide free DNS
494             service when you purchase a domain registration. When you transfer the
495             registration, the previous registrar will not renew your domain
496             registration and could end your DNS service at any time.
497              
498             If the registrar for your domain is also the DNS service provider for
499             the domain and you don't transfer DNS service to another provider, your
500             website, email, and the web applications associated with the domain
501             might become unavailable.
502              
503             If the transfer is successful, this method returns an operation ID that
504             you can use to track the progress and completion of the action. If the
505             transfer doesn't complete successfully, the domain registrant will be
506             notified by email.
507              
508              
509             =head2 UpdateDomainContact(DomainName => Str, [AdminContact => L<Paws::Route53Domains::ContactDetail>, RegistrantContact => L<Paws::Route53Domains::ContactDetail>, TechContact => L<Paws::Route53Domains::ContactDetail>])
510              
511             Each argument is described in detail in: L<Paws::Route53Domains::UpdateDomainContact>
512              
513             Returns: a L<Paws::Route53Domains::UpdateDomainContactResponse> instance
514              
515             This operation updates the contact information for a particular domain.
516             Information for at least one contact (registrant, administrator, or
517             technical) must be supplied for update.
518              
519             If the update is successful, this method returns an operation ID that
520             you can use to track the progress and completion of the action. If the
521             request is not completed successfully, the domain registrant will be
522             notified by email.
523              
524              
525             =head2 UpdateDomainContactPrivacy(DomainName => Str, [AdminPrivacy => Bool, RegistrantPrivacy => Bool, TechPrivacy => Bool])
526              
527             Each argument is described in detail in: L<Paws::Route53Domains::UpdateDomainContactPrivacy>
528              
529             Returns: a L<Paws::Route53Domains::UpdateDomainContactPrivacyResponse> instance
530              
531             This operation updates the specified domain contact's privacy setting.
532             When the privacy option is enabled, personal information such as postal
533             or email address is hidden from the results of a public WHOIS query.
534             The privacy services are provided by the AWS registrar, Gandi. For more
535             information, see the Gandi privacy features.
536              
537             This operation only affects the privacy of the specified contact type
538             (registrant, administrator, or tech). Successful acceptance returns an
539             operation ID that you can use with GetOperationDetail to track the
540             progress and completion of the action. If the request is not completed
541             successfully, the domain registrant will be notified by email.
542              
543              
544             =head2 UpdateDomainNameservers(DomainName => Str, Nameservers => ArrayRef[L<Paws::Route53Domains::Nameserver>], [FIAuthKey => Str])
545              
546             Each argument is described in detail in: L<Paws::Route53Domains::UpdateDomainNameservers>
547              
548             Returns: a L<Paws::Route53Domains::UpdateDomainNameserversResponse> instance
549              
550             This operation replaces the current set of name servers for the domain
551             with the specified set of name servers. If you use Amazon Route 53 as
552             your DNS service, specify the four name servers in the delegation set
553             for the hosted zone for the domain.
554              
555             If successful, this operation returns an operation ID that you can use
556             to track the progress and completion of the action. If the request is
557             not completed successfully, the domain registrant will be notified by
558             email.
559              
560              
561             =head2 UpdateTagsForDomain(DomainName => Str, [TagsToUpdate => ArrayRef[L<Paws::Route53Domains::Tag>]])
562              
563             Each argument is described in detail in: L<Paws::Route53Domains::UpdateTagsForDomain>
564              
565             Returns: a L<Paws::Route53Domains::UpdateTagsForDomainResponse> instance
566              
567             This operation adds or updates tags for a specified domain.
568              
569             All tag operations are eventually consistent; subsequent operations
570             might not immediately represent all issued operations.
571              
572              
573             =head2 ViewBilling([End => Str, Marker => Str, MaxItems => Int, Start => Str])
574              
575             Each argument is described in detail in: L<Paws::Route53Domains::ViewBilling>
576              
577             Returns: a L<Paws::Route53Domains::ViewBillingResponse> instance
578              
579             Returns all the domain-related billing records for the current AWS
580             account for a specified period
581              
582              
583              
584              
585             =head1 PAGINATORS
586              
587             Paginator methods are helpers that repetively call methods that return partial results
588              
589             =head2 ListAllDomains(sub { },[Marker => Str, MaxItems => Int])
590              
591             =head2 ListAllDomains([Marker => Str, MaxItems => Int])
592              
593              
594             If passed a sub as first parameter, it will call the sub for each element found in :
595              
596             - Domains, passing the object as the first parameter, and the string 'Domains' as the second parameter
597              
598             If not, it will return a a L<Paws::Route53Domains::ListDomainsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
599              
600              
601             =head2 ListAllOperations(sub { },[Marker => Str, MaxItems => Int])
602              
603             =head2 ListAllOperations([Marker => Str, MaxItems => Int])
604              
605              
606             If passed a sub as first parameter, it will call the sub for each element found in :
607              
608             - Operations, passing the object as the first parameter, and the string 'Operations' as the second parameter
609              
610             If not, it will return a a L<Paws::Route53Domains::ListOperationsResponse> instance with all the C<param>s; from all the responses. Please take into account that this mode can potentially consume vasts ammounts of memory.
611              
612              
613              
614              
615              
616             =head1 SEE ALSO
617              
618             This service class forms part of L<Paws>
619              
620             =head1 BUGS and CONTRIBUTIONS
621              
622             The source code is located here: https://github.com/pplu/aws-sdk-perl
623              
624             Please report bugs to: https://github.com/pplu/aws-sdk-perl/issues
625              
626             =cut
627