SlidesAsyncApi.pm untested

filter: Statementstmt 0.0% 0 / 504 Branchbran 0.0% 0 / 240 Conditioncond 0.0% 0 / 273 MC/DCmcdc 0.0% 0 / 162 Subroutinesub 0.0% 0 / 22 Podpod 0.0% 0 / 13 totaltotal 0.0% 0 / 1214 CC 121 SCAR 52.4
CC
121
Cov
0%
start_split
342.0
start_upload_and_split
306.0
start_save_presentation
272.0
CRAP 188.3
1 =begin comment
2  
3 Copyright (c) 2019 Aspose Pty Ltd
4  
5 Permission is hereby granted, free of charge, to any person obtaining a copy
6 of this software and associated documentation files (the "Software"), to deal
7 in the Software without restriction, including without limitation the rights
8 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
9 copies of the Software, and to permit persons to whom the Software is
10 furnished to do so, subject to the following conditions:
11  
12 The above copyright notice and this permission notice shall be included in all
13 copies or substantial portions of the Software.
14  
15 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 SOFTWARE.
22  
23 =end comment
24  
25 =cut
26  
27 package AsposeSlidesCloud::SlidesAsyncApi;
28  
29 require 5.6.0;
30 use strict;
31 use warnings;
32 use utf8;
33 use Exporter;
34 use Carp qw( croak );
35 use Log::Any qw($log);
36  
37 use AsposeSlidesCloud::ApiClient;
38  
39 use base "Class::Data::Inheritable";
40  
41 __PACKAGE__->mk_classdata('method_documentation' => {});
42  
43 sub new {
44 my $class = shift;
45 my %params = @_;
46 my $api_client = AsposeSlidesCloud::ApiClient->new(@_);
47  
48 bless { api_client => $api_client }, $class;
49 }
50  
51  
52 #
53 # download
54 #
55 #
56 #
57 # @param string $path (required)
58 # @param string $storage_name (optional)
59 # @param string $version_id (optional)
60 {
61 my $params = {
62 'path' => {
63 data_type => 'string',
64 description => '',
65 required => '1',
66 },
67 'storage_name' => {
68 data_type => 'string',
69 description => '',
70 required => '0',
71 },
72 'version_id' => {
73 data_type => 'string',
74 description => '',
75 required => '0',
76 },
77 };
78 __PACKAGE__->method_documentation->{ 'download' } = {
79 summary => '',
80 params => $params,
81 returns => 'File',
82 };
83 }
84 # @return File
85 #
86 sub download {
87 my ($self, %args) = @_;
88  
89 # verify the required parameter 'path' is set
90 unless (exists $args{'path'} && defined $args{'path'} && $args{'path'}) {
91 croak("Missing the required parameter 'path' when calling download");
92 }
93  
94 # parse inputs
95 my $_resource_path = '/slides/async/storage/file/{path}';
96  
97 my $_method = 'GET';
98 my $query_params = {};
99 my $header_params = {};
100 my $form_params = {};
101  
102 # 'Accept' and 'Content-Type' header
103 my $_header_accept = $self->{api_client}->select_header_accept('multipart/form-data');
104 if ($_header_accept) {
105 $header_params->{'Accept'} = $_header_accept;
106 }
107 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
108  
109 # query params
110 if (exists $args{'storage_name'} && defined $args{'storage_name'}) {
111 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
112 }
113  
114 # query params
115 if (exists $args{'version_id'} && defined $args{'version_id'}) {
116 $query_params->{'versionId'} = $self->{api_client}->to_query_value($args{'version_id'});
117 }
118  
119 # path params
120 if ( exists $args{'path'}) {
121 my $_base_variable = "{" . "path" . "}";
122 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
123 $_resource_path =~ s/$_base_variable/$_base_value/g;
124 }
125  
126 my $_body_data;
127 my $files = [];
128 # make the API Call
129 my $response = $self->{api_client}->call_api($_resource_path, $_method,
130 $query_params, $form_params,
131 $header_params, $_body_data, $files);
132 if (!$response) {
133 return;
134 }
135 my $_response_object = $self->{api_client}->deserialize('File', $response);
136 return $_response_object;
137 }
138  
139 #
140 # get_operation_result
141 #
142 #
143 #
144 # @param string $id (required)
145 {
146 my $params = {
147 'id' => {
148 data_type => 'string',
149 description => '',
150 required => '1',
151 },
152 };
153 __PACKAGE__->method_documentation->{ 'get_operation_result' } = {
154 summary => '',
155 params => $params,
156 returns => 'File',
157 };
158 }
159 # @return File
160 #
161 sub get_operation_result {
162 my ($self, %args) = @_;
163  
164 # verify the required parameter 'id' is set
165 unless (exists $args{'id'} && defined $args{'id'} && $args{'id'}) {
166 croak("Missing the required parameter 'id' when calling get_operation_result");
167 }
168  
169 # parse inputs
170 my $_resource_path = '/slides/async/{id}/result';
171  
172 my $_method = 'GET';
173 my $query_params = {};
174 my $header_params = {};
175 my $form_params = {};
176  
177 # 'Accept' and 'Content-Type' header
178 my $_header_accept = $self->{api_client}->select_header_accept('multipart/form-data');
179 if ($_header_accept) {
180 $header_params->{'Accept'} = $_header_accept;
181 }
182 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
183  
184 # path params
185 if ( exists $args{'id'}) {
186 my $_base_variable = "{" . "id" . "}";
187 my $_base_value = $self->{api_client}->to_path_value($args{'id'});
188 $_resource_path =~ s/$_base_variable/$_base_value/g;
189 }
190  
191 my $_body_data;
192 my $files = [];
193 # make the API Call
194 my $response = $self->{api_client}->call_api($_resource_path, $_method,
195 $query_params, $form_params,
196 $header_params, $_body_data, $files);
197 if (!$response) {
198 return;
199 }
200 my $_response_object = $self->{api_client}->deserialize('File', $response);
201 return $_response_object;
202 }
203  
204 #
205 # get_operation_status
206 #
207 #
208 #
209 # @param string $id (required)
210 {
211 my $params = {
212 'id' => {
213 data_type => 'string',
214 description => '',
215 required => '1',
216 },
217 };
218 __PACKAGE__->method_documentation->{ 'get_operation_status' } = {
219 summary => '',
220 params => $params,
221 returns => 'Operation',
222 };
223 }
224 # @return Operation
225 #
226 sub get_operation_status {
227 my ($self, %args) = @_;
228  
229 # verify the required parameter 'id' is set
230 unless (exists $args{'id'} && defined $args{'id'} && $args{'id'}) {
231 croak("Missing the required parameter 'id' when calling get_operation_status");
232 }
233  
234 # parse inputs
235 my $_resource_path = '/slides/async/{id}';
236  
237 my $_method = 'GET';
238 my $query_params = {};
239 my $header_params = {};
240 my $form_params = {};
241  
242 # 'Accept' and 'Content-Type' header
243 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
244 if ($_header_accept) {
245 $header_params->{'Accept'} = $_header_accept;
246 }
247 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
248  
249 # path params
250 if ( exists $args{'id'}) {
251 my $_base_variable = "{" . "id" . "}";
252 my $_base_value = $self->{api_client}->to_path_value($args{'id'});
253 $_resource_path =~ s/$_base_variable/$_base_value/g;
254 }
255  
256 my $_body_data;
257 my $files = [];
258 # make the API Call
259 my $response = $self->{api_client}->call_api($_resource_path, $_method,
260 $query_params, $form_params,
261 $header_params, $_body_data, $files);
262 if (!$response) {
263 return;
264 }
265 my $_response_object = $self->{api_client}->deserialize('Operation', $response);
266 return $_response_object;
267 }
268  
269 #
270 # start_convert
271 #
272 #
273 #
274 # @param File $document Document data. (required)
275 # @param string $format (required)
276 # @param string $password (optional)
277 # @param string $storage (optional)
278 # @param string $fonts_folder (optional)
279 # @param int[] $slides (optional)
280 # @param ExportOptions $options (optional)
281 {
282 my $params = {
283 'document' => {
284 data_type => 'File',
285 description => 'Document data.',
286 required => '1',
287 },
288 'format' => {
289 data_type => 'string',
290 description => '',
291 required => '1',
292 },
293 'password' => {
294 data_type => 'string',
295 description => '',
296 required => '0',
297 },
298 'storage' => {
299 data_type => 'string',
300 description => '',
301 required => '0',
302 },
303 'fonts_folder' => {
304 data_type => 'string',
305 description => '',
306 required => '0',
307 },
308 'slides' => {
309 data_type => 'int[]',
310 description => '',
311 required => '0',
312 },
313 'options' => {
314 data_type => 'ExportOptions',
315 description => '',
316 required => '0',
317 },
318 };
319 __PACKAGE__->method_documentation->{ 'start_convert' } = {
320 summary => '',
321 params => $params,
322 returns => 'string',
323 };
324 }
325 # @return string
326 #
327 sub start_convert {
328 my ($self, %args) = @_;
329  
330 # verify the required parameter 'document' is set
331 unless (exists $args{'document'} && defined $args{'document'} && $args{'document'}) {
332 croak("Missing the required parameter 'document' when calling start_convert");
333 }
334  
335 # verify the required parameter 'format' is set
336 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
337 croak("Missing the required parameter 'format' when calling start_convert");
338 }
339  
340 # verify enum value
341 if (!grep(/^$args{'format'}$/i, ( 'Pdf', 'Xps', 'Tiff', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Pot', 'Potx', 'Potm', 'Html', 'Html5', 'Swf', 'Svg', 'Jpeg', 'Png', 'Gif', 'Bmp', 'Fodp', 'Xaml', 'Mpeg4', 'Md', 'Xml', 'Emf' ))) {
342 croak("Invalid value for 'format': " . $args{'format'});
343 }
344  
345 # parse inputs
346 my $_resource_path = '/slides/async/convert/{format}';
347  
348 my $_method = 'POST';
349 my $query_params = {};
350 my $header_params = {};
351 my $form_params = {};
352  
353 # 'Accept' and 'Content-Type' header
354 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
355 if ($_header_accept) {
356 $header_params->{'Accept'} = $_header_accept;
357 }
358 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
359  
360 # query params
361 if (exists $args{'storage'} && defined $args{'storage'}) {
362 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
363 }
364  
365 # query params
366 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
367 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
368 }
369  
370 # query params
371 if (exists $args{'slides'} && defined $args{'slides'}) {
372 $query_params->{'slides'} = $self->{api_client}->to_query_value($args{'slides'});
373 }
374  
375 # header params
376 if ( exists $args{'password'}) {
377 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
378 }
379  
380 # path params
381 if ( exists $args{'format'}) {
382 my $_base_variable = "{" . "format" . "}";
383 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
384 $_resource_path =~ s/$_base_variable/$_base_value/g;
385 }
386  
387 my $_body_data;
388 my $files = [];
389 if ( exists $args{'document'} && $args{'document'}) {
390 push(@$files, $args{'document'});
391 }
392 # body params
393 if ( exists $args{'options'} && $args{'options'}) {
394 $_body_data = $args{'options'};
395 }
396  
397 # make the API Call
398 my $response = $self->{api_client}->call_api($_resource_path, $_method,
399 $query_params, $form_params,
400 $header_params, $_body_data, $files);
401 if (!$response) {
402 return;
403 }
404 my $_response_object = $self->{api_client}->deserialize('string', $response);
405 return $_response_object;
406 }
407  
408 #
409 # start_convert_and_save
410 #
411 #
412 #
413 # @param File $document Document data. (required)
414 # @param string $format (required)
415 # @param string $out_path (required)
416 # @param string $password (optional)
417 # @param string $storage (optional)
418 # @param string $fonts_folder (optional)
419 # @param int[] $slides (optional)
420 # @param ExportOptions $options (optional)
421 {
422 my $params = {
423 'document' => {
424 data_type => 'File',
425 description => 'Document data.',
426 required => '1',
427 },
428 'format' => {
429 data_type => 'string',
430 description => '',
431 required => '1',
432 },
433 'out_path' => {
434 data_type => 'string',
435 description => '',
436 required => '1',
437 },
438 'password' => {
439 data_type => 'string',
440 description => '',
441 required => '0',
442 },
443 'storage' => {
444 data_type => 'string',
445 description => '',
446 required => '0',
447 },
448 'fonts_folder' => {
449 data_type => 'string',
450 description => '',
451 required => '0',
452 },
453 'slides' => {
454 data_type => 'int[]',
455 description => '',
456 required => '0',
457 },
458 'options' => {
459 data_type => 'ExportOptions',
460 description => '',
461 required => '0',
462 },
463 };
464 __PACKAGE__->method_documentation->{ 'start_convert_and_save' } = {
465 summary => '',
466 params => $params,
467 returns => 'string',
468 };
469 }
470 # @return string
471 #
472 sub start_convert_and_save {
473 my ($self, %args) = @_;
474  
475 # verify the required parameter 'document' is set
476 unless (exists $args{'document'} && defined $args{'document'} && $args{'document'}) {
477 croak("Missing the required parameter 'document' when calling start_convert_and_save");
478 }
479  
480 # verify the required parameter 'format' is set
481 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
482 croak("Missing the required parameter 'format' when calling start_convert_and_save");
483 }
484  
485 # verify enum value
486 if (!grep(/^$args{'format'}$/i, ( 'Pdf', 'Xps', 'Tiff', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Pot', 'Potx', 'Potm', 'Html', 'Html5', 'Swf', 'Svg', 'Jpeg', 'Png', 'Gif', 'Bmp', 'Fodp', 'Xaml', 'Mpeg4', 'Md', 'Xml', 'Emf' ))) {
487 croak("Invalid value for 'format': " . $args{'format'});
488 }
489  
490 # verify the required parameter 'out_path' is set
491 unless (exists $args{'out_path'} && defined $args{'out_path'} && $args{'out_path'}) {
492 croak("Missing the required parameter 'out_path' when calling start_convert_and_save");
493 }
494  
495 # parse inputs
496 my $_resource_path = '/slides/async/convert/{format}';
497  
498 my $_method = 'PUT';
499 my $query_params = {};
500 my $header_params = {};
501 my $form_params = {};
502  
503 # 'Accept' and 'Content-Type' header
504 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
505 if ($_header_accept) {
506 $header_params->{'Accept'} = $_header_accept;
507 }
508 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
509  
510 # query params
511 if (exists $args{'out_path'} && defined $args{'out_path'}) {
512 $query_params->{'outPath'} = $self->{api_client}->to_query_value($args{'out_path'});
513 }
514  
515 # query params
516 if (exists $args{'storage'} && defined $args{'storage'}) {
517 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
518 }
519  
520 # query params
521 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
522 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
523 }
524  
525 # query params
526 if (exists $args{'slides'} && defined $args{'slides'}) {
527 $query_params->{'slides'} = $self->{api_client}->to_query_value($args{'slides'});
528 }
529  
530 # header params
531 if ( exists $args{'password'}) {
532 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
533 }
534  
535 # path params
536 if ( exists $args{'format'}) {
537 my $_base_variable = "{" . "format" . "}";
538 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
539 $_resource_path =~ s/$_base_variable/$_base_value/g;
540 }
541  
542 my $_body_data;
543 my $files = [];
544 if ( exists $args{'document'} && $args{'document'}) {
545 push(@$files, $args{'document'});
546 }
547 # body params
548 if ( exists $args{'options'} && $args{'options'}) {
549 $_body_data = $args{'options'};
550 }
551  
552 # make the API Call
553 my $response = $self->{api_client}->call_api($_resource_path, $_method,
554 $query_params, $form_params,
555 $header_params, $_body_data, $files);
556 if (!$response) {
557 return;
558 }
559 my $_response_object = $self->{api_client}->deserialize('string', $response);
560 return $_response_object;
561 }
562  
563 #
564 # start_download_presentation
565 #
566 #
567 #
568 # @param string $name (required)
569 # @param string $format (required)
570 # @param ExportOptions $options (optional)
571 # @param string $password (optional)
572 # @param string $folder (optional)
573 # @param string $storage (optional)
574 # @param string $fonts_folder (optional)
575 # @param int[] $slides (optional)
576 {
577 my $params = {
578 'name' => {
579 data_type => 'string',
580 description => '',
581 required => '1',
582 },
583 'format' => {
584 data_type => 'string',
585 description => '',
586 required => '1',
587 },
588 'options' => {
589 data_type => 'ExportOptions',
590 description => '',
591 required => '0',
592 },
593 'password' => {
594 data_type => 'string',
595 description => '',
596 required => '0',
597 },
598 'folder' => {
599 data_type => 'string',
600 description => '',
601 required => '0',
602 },
603 'storage' => {
604 data_type => 'string',
605 description => '',
606 required => '0',
607 },
608 'fonts_folder' => {
609 data_type => 'string',
610 description => '',
611 required => '0',
612 },
613 'slides' => {
614 data_type => 'int[]',
615 description => '',
616 required => '0',
617 },
618 };
619 __PACKAGE__->method_documentation->{ 'start_download_presentation' } = {
620 summary => '',
621 params => $params,
622 returns => 'string',
623 };
624 }
625 # @return string
626 #
627 sub start_download_presentation {
628 my ($self, %args) = @_;
629  
630 # verify the required parameter 'name' is set
631 unless (exists $args{'name'} && defined $args{'name'} && $args{'name'}) {
632 croak("Missing the required parameter 'name' when calling start_download_presentation");
633 }
634  
635 # verify the required parameter 'format' is set
636 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
637 croak("Missing the required parameter 'format' when calling start_download_presentation");
638 }
639  
640 # verify enum value
641 if (!grep(/^$args{'format'}$/i, ( 'Pdf', 'Xps', 'Tiff', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Pot', 'Potx', 'Potm', 'Html', 'Html5', 'Swf', 'Svg', 'Jpeg', 'Png', 'Gif', 'Bmp', 'Fodp', 'Xaml', 'Mpeg4', 'Md', 'Xml', 'Emf' ))) {
642 croak("Invalid value for 'format': " . $args{'format'});
643 }
644  
645 # parse inputs
646 my $_resource_path = '/slides/async/{name}/{format}';
647  
648 my $_method = 'POST';
649 my $query_params = {};
650 my $header_params = {};
651 my $form_params = {};
652  
653 # 'Accept' and 'Content-Type' header
654 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
655 if ($_header_accept) {
656 $header_params->{'Accept'} = $_header_accept;
657 }
658 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
659  
660 # query params
661 if (exists $args{'folder'} && defined $args{'folder'}) {
662 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
663 }
664  
665 # query params
666 if (exists $args{'storage'} && defined $args{'storage'}) {
667 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
668 }
669  
670 # query params
671 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
672 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
673 }
674  
675 # query params
676 if (exists $args{'slides'} && defined $args{'slides'}) {
677 $query_params->{'slides'} = $self->{api_client}->to_query_value($args{'slides'});
678 }
679  
680 # header params
681 if ( exists $args{'password'}) {
682 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
683 }
684  
685 # path params
686 if ( exists $args{'name'}) {
687 my $_base_variable = "{" . "name" . "}";
688 my $_base_value = $self->{api_client}->to_path_value($args{'name'});
689 $_resource_path =~ s/$_base_variable/$_base_value/g;
690 }
691  
692 # path params
693 if ( exists $args{'format'}) {
694 my $_base_variable = "{" . "format" . "}";
695 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
696 $_resource_path =~ s/$_base_variable/$_base_value/g;
697 }
698  
699 my $_body_data;
700 my $files = [];
701 # body params
702 if ( exists $args{'options'} && $args{'options'}) {
703 $_body_data = $args{'options'};
704 }
705  
706 # make the API Call
707 my $response = $self->{api_client}->call_api($_resource_path, $_method,
708 $query_params, $form_params,
709 $header_params, $_body_data, $files);
710 if (!$response) {
711 return;
712 }
713 my $_response_object = $self->{api_client}->deserialize('string', $response);
714 return $_response_object;
715 }
716  
717 #
718 # start_merge
719 #
720 #
721 #
722 # @param ARRAY[string] $files Files to merge (optional)
723 # @param OrderedMergeRequest $request (optional)
724 # @param string $storage (optional)
725 {
726 my $params = {
727 'files' => {
728 data_type => 'ARRAY[string]',
729 description => 'Files to merge',
730 required => '0',
731 },
732 'request' => {
733 data_type => 'OrderedMergeRequest',
734 description => '',
735 required => '0',
736 },
737 'storage' => {
738 data_type => 'string',
739 description => '',
740 required => '0',
741 },
742 };
743 __PACKAGE__->method_documentation->{ 'start_merge' } = {
744 summary => '',
745 params => $params,
746 returns => 'string',
747 };
748 }
749 # @return string
750 #
751 sub start_merge {
752 my ($self, %args) = @_;
753  
754 # parse inputs
755 my $_resource_path = '/slides/async/merge';
756  
757 my $_method = 'POST';
758 my $query_params = {};
759 my $header_params = {};
760 my $form_params = {};
761  
762 # 'Accept' and 'Content-Type' header
763 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
764 if ($_header_accept) {
765 $header_params->{'Accept'} = $_header_accept;
766 }
767 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
768  
769 # query params
770 if (exists $args{'storage'} && defined $args{'storage'}) {
771 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
772 }
773  
774 my $_body_data;
775 my $files = [];
776 if ( exists $args{'files'} && $args{'files'}) {
777 my $arg_files = $args{'files'};
778 push(@$files, @$arg_files);
779 }
780 # body params
781 if ( exists $args{'request'} && $args{'request'}) {
782 $_body_data = $args{'request'};
783 }
784  
785 # make the API Call
786 my $response = $self->{api_client}->call_api($_resource_path, $_method,
787 $query_params, $form_params,
788 $header_params, $_body_data, $files);
789 if (!$response) {
790 return;
791 }
792 my $_response_object = $self->{api_client}->deserialize('string', $response);
793 return $_response_object;
794 }
795  
796 #
797 # start_merge_and_save
798 #
799 #
800 #
801 # @param string $out_path (required)
802 # @param ARRAY[string] $files Files to merge (optional)
803 # @param OrderedMergeRequest $request (optional)
804 # @param string $storage (optional)
805 {
806 my $params = {
807 'out_path' => {
808 data_type => 'string',
809 description => '',
810 required => '1',
811 },
812 'files' => {
813 data_type => 'ARRAY[string]',
814 description => 'Files to merge',
815 required => '0',
816 },
817 'request' => {
818 data_type => 'OrderedMergeRequest',
819 description => '',
820 required => '0',
821 },
822 'storage' => {
823 data_type => 'string',
824 description => '',
825 required => '0',
826 },
827 };
828 __PACKAGE__->method_documentation->{ 'start_merge_and_save' } = {
829 summary => '',
830 params => $params,
831 returns => 'string',
832 };
833 }
834 # @return string
835 #
836 sub start_merge_and_save {
837 my ($self, %args) = @_;
838  
839 # verify the required parameter 'out_path' is set
840 unless (exists $args{'out_path'} && defined $args{'out_path'} && $args{'out_path'}) {
841 croak("Missing the required parameter 'out_path' when calling start_merge_and_save");
842 }
843  
844 # parse inputs
845 my $_resource_path = '/slides/async/merge';
846  
847 my $_method = 'PUT';
848 my $query_params = {};
849 my $header_params = {};
850 my $form_params = {};
851  
852 # 'Accept' and 'Content-Type' header
853 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
854 if ($_header_accept) {
855 $header_params->{'Accept'} = $_header_accept;
856 }
857 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
858  
859 # query params
860 if (exists $args{'out_path'} && defined $args{'out_path'}) {
861 $query_params->{'outPath'} = $self->{api_client}->to_query_value($args{'out_path'});
862 }
863  
864 # query params
865 if (exists $args{'storage'} && defined $args{'storage'}) {
866 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
867 }
868  
869 my $_body_data;
870 my $files = [];
871 if ( exists $args{'files'} && $args{'files'}) {
872 my $arg_files = $args{'files'};
873 push(@$files, @$arg_files);
874 }
875 # body params
876 if ( exists $args{'request'} && $args{'request'}) {
877 $_body_data = $args{'request'};
878 }
879  
880 # make the API Call
881 my $response = $self->{api_client}->call_api($_resource_path, $_method,
882 $query_params, $form_params,
883 $header_params, $_body_data, $files);
884 if (!$response) {
885 return;
886 }
887 my $_response_object = $self->{api_client}->deserialize('string', $response);
888 return $_response_object;
889 }
890  
891 #
892 # start_save_presentation
893 #
894 #
895 #
896 # @param string $name (required)
897 # @param string $format (required)
898 # @param string $out_path (required)
899 # @param ExportOptions $options (optional)
900 # @param string $password (optional)
901 # @param string $folder (optional)
902 # @param string $storage (optional)
903 # @param string $fonts_folder (optional)
904 # @param int[] $slides (optional)
905 {
906 my $params = {
907 'name' => {
908 data_type => 'string',
909 description => '',
910 required => '1',
911 },
912 'format' => {
913 data_type => 'string',
914 description => '',
915 required => '1',
916 },
917 'out_path' => {
918 data_type => 'string',
919 description => '',
920 required => '1',
921 },
922 'options' => {
923 data_type => 'ExportOptions',
924 description => '',
925 required => '0',
926 },
927 'password' => {
928 data_type => 'string',
929 description => '',
930 required => '0',
931 },
932 'folder' => {
933 data_type => 'string',
934 description => '',
935 required => '0',
936 },
937 'storage' => {
938 data_type => 'string',
939 description => '',
940 required => '0',
941 },
942 'fonts_folder' => {
943 data_type => 'string',
944 description => '',
945 required => '0',
946 },
947 'slides' => {
948 data_type => 'int[]',
949 description => '',
950 required => '0',
951 },
952 };
953 __PACKAGE__->method_documentation->{ 'start_save_presentation' } = {
954 summary => '',
955 params => $params,
956 returns => 'string',
957 };
958 }
959 # @return string
960 #
961 sub start_save_presentation {
962 my ($self, %args) = @_;
963  
964 # verify the required parameter 'name' is set
965 unless (exists $args{'name'} && defined $args{'name'} && $args{'name'}) {
966 croak("Missing the required parameter 'name' when calling start_save_presentation");
967 }
968  
969 # verify the required parameter 'format' is set
970 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
971 croak("Missing the required parameter 'format' when calling start_save_presentation");
972 }
973  
974 # verify enum value
975 if (!grep(/^$args{'format'}$/i, ( 'Pdf', 'Xps', 'Tiff', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Pot', 'Potx', 'Potm', 'Html', 'Html5', 'Swf', 'Svg', 'Jpeg', 'Png', 'Gif', 'Bmp', 'Fodp', 'Xaml', 'Mpeg4', 'Md', 'Xml', 'Emf' ))) {
976 croak("Invalid value for 'format': " . $args{'format'});
977 }
978  
979 # verify the required parameter 'out_path' is set
980 unless (exists $args{'out_path'} && defined $args{'out_path'} && $args{'out_path'}) {
981 croak("Missing the required parameter 'out_path' when calling start_save_presentation");
982 }
983  
984 # parse inputs
985 my $_resource_path = '/slides/async/{name}/{format}';
986  
987 my $_method = 'PUT';
988 my $query_params = {};
989 my $header_params = {};
990 my $form_params = {};
991  
992 # 'Accept' and 'Content-Type' header
993 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
994 if ($_header_accept) {
995 $header_params->{'Accept'} = $_header_accept;
996 }
997 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
998  
999 # query params
1000 if (exists $args{'out_path'} && defined $args{'out_path'}) {
1001 $query_params->{'outPath'} = $self->{api_client}->to_query_value($args{'out_path'});
1002 }
1003  
1004 # query params
1005 if (exists $args{'folder'} && defined $args{'folder'}) {
1006 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1007 }
1008  
1009 # query params
1010 if (exists $args{'storage'} && defined $args{'storage'}) {
1011 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1012 }
1013  
1014 # query params
1015 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
1016 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
1017 }
1018  
1019 # query params
1020 if (exists $args{'slides'} && defined $args{'slides'}) {
1021 $query_params->{'slides'} = $self->{api_client}->to_query_value($args{'slides'});
1022 }
1023  
1024 # header params
1025 if ( exists $args{'password'}) {
1026 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
1027 }
1028  
1029 # path params
1030 if ( exists $args{'name'}) {
1031 my $_base_variable = "{" . "name" . "}";
1032 my $_base_value = $self->{api_client}->to_path_value($args{'name'});
1033 $_resource_path =~ s/$_base_variable/$_base_value/g;
1034 }
1035  
1036 # path params
1037 if ( exists $args{'format'}) {
1038 my $_base_variable = "{" . "format" . "}";
1039 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
1040 $_resource_path =~ s/$_base_variable/$_base_value/g;
1041 }
1042  
1043 my $_body_data;
1044 my $files = [];
1045 # body params
1046 if ( exists $args{'options'} && $args{'options'}) {
1047 $_body_data = $args{'options'};
1048 }
1049  
1050 # make the API Call
1051 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1052 $query_params, $form_params,
1053 $header_params, $_body_data, $files);
1054 if (!$response) {
1055 return;
1056 }
1057 my $_response_object = $self->{api_client}->deserialize('string', $response);
1058 return $_response_object;
1059 }
1060  
1061 #
1062 # start_split
1063 #
1064 #
1065 #
1066 # @param string $name (required)
1067 # @param string $format (required)
1068 # @param ExportOptions $options (optional)
1069 # @param int $width (optional)
1070 # @param int $height (optional)
1071 # @param int $from (optional)
1072 # @param int $to (optional)
1073 # @param string $dest_folder (optional)
1074 # @param string $password (optional)
1075 # @param string $folder (optional)
1076 # @param string $storage (optional)
1077 # @param string $fonts_folder (optional)
1078 {
1079 my $params = {
1080 'name' => {
1081 data_type => 'string',
1082 description => '',
1083 required => '1',
1084 },
1085 'format' => {
1086 data_type => 'string',
1087 description => '',
1088 required => '1',
1089 },
1090 'options' => {
1091 data_type => 'ExportOptions',
1092 description => '',
1093 required => '0',
1094 },
1095 'width' => {
1096 data_type => 'int',
1097 description => '',
1098 required => '0',
1099 },
1100 'height' => {
1101 data_type => 'int',
1102 description => '',
1103 required => '0',
1104 },
1105 'from' => {
1106 data_type => 'int',
1107 description => '',
1108 required => '0',
1109 },
1110 'to' => {
1111 data_type => 'int',
1112 description => '',
1113 required => '0',
1114 },
1115 'dest_folder' => {
1116 data_type => 'string',
1117 description => '',
1118 required => '0',
1119 },
1120 'password' => {
1121 data_type => 'string',
1122 description => '',
1123 required => '0',
1124 },
1125 'folder' => {
1126 data_type => 'string',
1127 description => '',
1128 required => '0',
1129 },
1130 'storage' => {
1131 data_type => 'string',
1132 description => '',
1133 required => '0',
1134 },
1135 'fonts_folder' => {
1136 data_type => 'string',
1137 description => '',
1138 required => '0',
1139 },
1140 };
1141 __PACKAGE__->method_documentation->{ 'start_split' } = {
1142 summary => '',
1143 params => $params,
1144 returns => 'string',
1145 };
1146 }
1147 # @return string
1148 #
1149 sub start_split {
1150 my ($self, %args) = @_;
1151  
1152 # verify the required parameter 'name' is set
1153 unless (exists $args{'name'} && defined $args{'name'} && $args{'name'}) {
1154 croak("Missing the required parameter 'name' when calling start_split");
1155 }
1156  
1157 # verify the required parameter 'format' is set
1158 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
1159 croak("Missing the required parameter 'format' when calling start_split");
1160 }
1161  
1162 # verify enum value
1163 if (!grep(/^$args{'format'}$/i, ( 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff', 'Html', 'Pdf', 'Xps', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Potx', 'Pot', 'Potm', 'Svg', 'Fodp', 'Xaml', 'Html5', 'Md', 'Xml', 'Emf' ))) {
1164 croak("Invalid value for 'format': " . $args{'format'});
1165 }
1166  
1167 # parse inputs
1168 my $_resource_path = '/slides/async/{name}/split/{format}';
1169  
1170 my $_method = 'POST';
1171 my $query_params = {};
1172 my $header_params = {};
1173 my $form_params = {};
1174  
1175 # 'Accept' and 'Content-Type' header
1176 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1177 if ($_header_accept) {
1178 $header_params->{'Accept'} = $_header_accept;
1179 }
1180 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('application/json');
1181  
1182 # query params
1183 if (exists $args{'width'} && defined $args{'width'}) {
1184 $query_params->{'width'} = $self->{api_client}->to_query_value($args{'width'});
1185 }
1186  
1187 # query params
1188 if (exists $args{'height'} && defined $args{'height'}) {
1189 $query_params->{'height'} = $self->{api_client}->to_query_value($args{'height'});
1190 }
1191  
1192 # query params
1193 if (exists $args{'from'} && defined $args{'from'}) {
1194 $query_params->{'from'} = $self->{api_client}->to_query_value($args{'from'});
1195 }
1196  
1197 # query params
1198 if (exists $args{'to'} && defined $args{'to'}) {
1199 $query_params->{'to'} = $self->{api_client}->to_query_value($args{'to'});
1200 }
1201  
1202 # query params
1203 if (exists $args{'dest_folder'} && defined $args{'dest_folder'}) {
1204 $query_params->{'destFolder'} = $self->{api_client}->to_query_value($args{'dest_folder'});
1205 }
1206  
1207 # query params
1208 if (exists $args{'folder'} && defined $args{'folder'}) {
1209 $query_params->{'folder'} = $self->{api_client}->to_query_value($args{'folder'});
1210 }
1211  
1212 # query params
1213 if (exists $args{'storage'} && defined $args{'storage'}) {
1214 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1215 }
1216  
1217 # query params
1218 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
1219 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
1220 }
1221  
1222 # header params
1223 if ( exists $args{'password'}) {
1224 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
1225 }
1226  
1227 # path params
1228 if ( exists $args{'name'}) {
1229 my $_base_variable = "{" . "name" . "}";
1230 my $_base_value = $self->{api_client}->to_path_value($args{'name'});
1231 $_resource_path =~ s/$_base_variable/$_base_value/g;
1232 }
1233  
1234 # path params
1235 if ( exists $args{'format'}) {
1236 my $_base_variable = "{" . "format" . "}";
1237 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
1238 $_resource_path =~ s/$_base_variable/$_base_value/g;
1239 }
1240  
1241 my $_body_data;
1242 my $files = [];
1243 # body params
1244 if ( exists $args{'options'} && $args{'options'}) {
1245 $_body_data = $args{'options'};
1246 }
1247  
1248 # make the API Call
1249 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1250 $query_params, $form_params,
1251 $header_params, $_body_data, $files);
1252 if (!$response) {
1253 return;
1254 }
1255 my $_response_object = $self->{api_client}->deserialize('string', $response);
1256 return $_response_object;
1257 }
1258  
1259 #
1260 # start_upload_and_split
1261 #
1262 #
1263 #
1264 # @param File $document Document data. (required)
1265 # @param string $format (required)
1266 # @param string $dest_folder (optional, default to )
1267 # @param int $width (optional)
1268 # @param int $height (optional)
1269 # @param int $from (optional)
1270 # @param int $to (optional)
1271 # @param string $password (optional)
1272 # @param string $storage (optional)
1273 # @param string $fonts_folder (optional)
1274 # @param ExportOptions $options (optional)
1275 {
1276 my $params = {
1277 'document' => {
1278 data_type => 'File',
1279 description => 'Document data.',
1280 required => '1',
1281 },
1282 'format' => {
1283 data_type => 'string',
1284 description => '',
1285 required => '1',
1286 },
1287 'dest_folder' => {
1288 data_type => 'string',
1289 description => '',
1290 required => '0',
1291 },
1292 'width' => {
1293 data_type => 'int',
1294 description => '',
1295 required => '0',
1296 },
1297 'height' => {
1298 data_type => 'int',
1299 description => '',
1300 required => '0',
1301 },
1302 'from' => {
1303 data_type => 'int',
1304 description => '',
1305 required => '0',
1306 },
1307 'to' => {
1308 data_type => 'int',
1309 description => '',
1310 required => '0',
1311 },
1312 'password' => {
1313 data_type => 'string',
1314 description => '',
1315 required => '0',
1316 },
1317 'storage' => {
1318 data_type => 'string',
1319 description => '',
1320 required => '0',
1321 },
1322 'fonts_folder' => {
1323 data_type => 'string',
1324 description => '',
1325 required => '0',
1326 },
1327 'options' => {
1328 data_type => 'ExportOptions',
1329 description => '',
1330 required => '0',
1331 },
1332 };
1333 __PACKAGE__->method_documentation->{ 'start_upload_and_split' } = {
1334 summary => '',
1335 params => $params,
1336 returns => 'string',
1337 };
1338 }
1339 # @return string
1340 #
1341 sub start_upload_and_split {
1342 my ($self, %args) = @_;
1343  
1344 # verify the required parameter 'document' is set
1345 unless (exists $args{'document'} && defined $args{'document'} && $args{'document'}) {
1346 croak("Missing the required parameter 'document' when calling start_upload_and_split");
1347 }
1348  
1349 # verify the required parameter 'format' is set
1350 unless (exists $args{'format'} && defined $args{'format'} && $args{'format'}) {
1351 croak("Missing the required parameter 'format' when calling start_upload_and_split");
1352 }
1353  
1354 # verify enum value
1355 if (!grep(/^$args{'format'}$/i, ( 'Jpeg', 'Png', 'Gif', 'Bmp', 'Tiff', 'Html', 'Pdf', 'Xps', 'Pptx', 'Odp', 'Otp', 'Ppt', 'Pps', 'Ppsx', 'Pptm', 'Ppsm', 'Potx', 'Pot', 'Potm', 'Svg', 'Fodp', 'Xaml', 'Html5', 'Md', 'Xml', 'Emf' ))) {
1356 croak("Invalid value for 'format': " . $args{'format'});
1357 }
1358  
1359 # parse inputs
1360 my $_resource_path = '/slides/async/split/{format}';
1361  
1362 my $_method = 'POST';
1363 my $query_params = {};
1364 my $header_params = {};
1365 my $form_params = {};
1366  
1367 # 'Accept' and 'Content-Type' header
1368 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1369 if ($_header_accept) {
1370 $header_params->{'Accept'} = $_header_accept;
1371 }
1372 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
1373  
1374 # query params
1375 if (exists $args{'dest_folder'} && defined $args{'dest_folder'}) {
1376 $query_params->{'destFolder'} = $self->{api_client}->to_query_value($args{'dest_folder'});
1377 }
1378  
1379 # query params
1380 if (exists $args{'width'} && defined $args{'width'}) {
1381 $query_params->{'width'} = $self->{api_client}->to_query_value($args{'width'});
1382 }
1383  
1384 # query params
1385 if (exists $args{'height'} && defined $args{'height'}) {
1386 $query_params->{'height'} = $self->{api_client}->to_query_value($args{'height'});
1387 }
1388  
1389 # query params
1390 if (exists $args{'from'} && defined $args{'from'}) {
1391 $query_params->{'from'} = $self->{api_client}->to_query_value($args{'from'});
1392 }
1393  
1394 # query params
1395 if (exists $args{'to'} && defined $args{'to'}) {
1396 $query_params->{'to'} = $self->{api_client}->to_query_value($args{'to'});
1397 }
1398  
1399 # query params
1400 if (exists $args{'storage'} && defined $args{'storage'}) {
1401 $query_params->{'storage'} = $self->{api_client}->to_query_value($args{'storage'});
1402 }
1403  
1404 # query params
1405 if (exists $args{'fonts_folder'} && defined $args{'fonts_folder'}) {
1406 $query_params->{'fontsFolder'} = $self->{api_client}->to_query_value($args{'fonts_folder'});
1407 }
1408  
1409 # header params
1410 if ( exists $args{'password'}) {
1411 $header_params->{':password'} = $self->{api_client}->to_header_value($args{'password'});
1412 }
1413  
1414 # path params
1415 if ( exists $args{'format'}) {
1416 my $_base_variable = "{" . "format" . "}";
1417 my $_base_value = $self->{api_client}->to_path_value($args{'format'});
1418 $_resource_path =~ s/$_base_variable/$_base_value/g;
1419 }
1420  
1421 my $_body_data;
1422 my $files = [];
1423 if ( exists $args{'document'} && $args{'document'}) {
1424 push(@$files, $args{'document'});
1425 }
1426 # body params
1427 if ( exists $args{'options'} && $args{'options'}) {
1428 $_body_data = $args{'options'};
1429 }
1430  
1431 # make the API Call
1432 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1433 $query_params, $form_params,
1434 $header_params, $_body_data, $files);
1435 if (!$response) {
1436 return;
1437 }
1438 my $_response_object = $self->{api_client}->deserialize('string', $response);
1439 return $_response_object;
1440 }
1441  
1442 #
1443 # upload
1444 #
1445 #
1446 #
1447 # @param string $path (required)
1448 # @param File $file File to upload (required)
1449 # @param string $storage_name (optional)
1450 {
1451 my $params = {
1452 'path' => {
1453 data_type => 'string',
1454 description => '',
1455 required => '1',
1456 },
1457 'file' => {
1458 data_type => 'File',
1459 description => 'File to upload',
1460 required => '1',
1461 },
1462 'storage_name' => {
1463 data_type => 'string',
1464 description => '',
1465 required => '0',
1466 },
1467 };
1468 __PACKAGE__->method_documentation->{ 'upload' } = {
1469 summary => '',
1470 params => $params,
1471 returns => 'FilesUploadResult',
1472 };
1473 }
1474 # @return FilesUploadResult
1475 #
1476 sub upload {
1477 my ($self, %args) = @_;
1478  
1479 # verify the required parameter 'path' is set
1480 unless (exists $args{'path'} && defined $args{'path'} && $args{'path'}) {
1481 croak("Missing the required parameter 'path' when calling upload");
1482 }
1483  
1484 # verify the required parameter 'file' is set
1485 unless (exists $args{'file'} && defined $args{'file'} && $args{'file'}) {
1486 croak("Missing the required parameter 'file' when calling upload");
1487 }
1488  
1489 # parse inputs
1490 my $_resource_path = '/slides/async/storage/file/{path}';
1491  
1492 my $_method = 'PUT';
1493 my $query_params = {};
1494 my $header_params = {};
1495 my $form_params = {};
1496  
1497 # 'Accept' and 'Content-Type' header
1498 my $_header_accept = $self->{api_client}->select_header_accept('application/json');
1499 if ($_header_accept) {
1500 $header_params->{'Accept'} = $_header_accept;
1501 }
1502 $header_params->{'Content-Type'} = $self->{api_client}->select_header_content_type('multipart/form-data');
1503  
1504 # query params
1505 if (exists $args{'storage_name'} && defined $args{'storage_name'}) {
1506 $query_params->{'storageName'} = $self->{api_client}->to_query_value($args{'storage_name'});
1507 }
1508  
1509 # path params
1510 if ( exists $args{'path'}) {
1511 my $_base_variable = "{" . "path" . "}";
1512 my $_base_value = $self->{api_client}->to_path_value($args{'path'});
1513 $_resource_path =~ s/$_base_variable/$_base_value/g;
1514 }
1515  
1516 my $_body_data;
1517 my $files = [];
1518 if ( exists $args{'file'} && $args{'file'}) {
1519 push(@$files, $args{'file'});
1520 }
1521 # make the API Call
1522 my $response = $self->{api_client}->call_api($_resource_path, $_method,
1523 $query_params, $form_params,
1524 $header_params, $_body_data, $files);
1525 if (!$response) {
1526 return;
1527 }
1528 my $_response_object = $self->{api_client}->deserialize('FilesUploadResult', $response);
1529 return $_response_object;
1530 }
1531  
1532 1;