Calculate Cells formula

This REST API indicates calculate cells formula in an Excel file.

RSET API

 
POST http://api.aspose.cloud/v3.0/cells/{name}/worksheets/{sheetName}/cells/{cellName}/calculate

The request parameters are:

Parameter Name	Type	Path/Query String/HTTPBody	Description
name	string	path
sheetName	string	path
cellName	string	path
options		body
folder	string	query
storageName	string	query	storage name.

The OpenAPI Specification defines a publicly accessible programming interface and lets you carry out REST interactions directly from a web browser.

You can use cURL command-line tool to access Aspose.Cells web services easily. The following example shows how to make calls to Cloud API with cURL.

Request

 
curl -v "http://api.aspose.cloud/v3.0/cells/Book1.xlsx/worksheets/Sheet1/cells/A1/calculate" \
-d '{"CalcStackSize": "1"}' \
-X POST \
-H "Content-Type: application/json" \
-H "Accept: application/json" \
-H "Authorization: Bearer <jwt token>"

Response

{
"Code": 200,
"Status": "OK"
}

Cloud SDK Family

Using an SDK is the best way to speed up the development. An SDK takes care of low-level details and lets you focus on your project tasks. Please check out the GitHub repository for a complete list of Aspose.Cells Cloud SDKs.

The following code examples demonstrate how to make calls to Aspose.Cells web services using various SDKs:

	// For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-dotnet/
	namespace Aspose.Cells.Cloud.SDK.Example
	{
	using Aspose.Cells.Cloud.SDK.Api;
	using Aspose.Cells.Cloud.SDK.Request;
	using System;

	public partial class CellsApiExample
	{
	public void PostWorkbookCalculateFormula2Example()
	{
	CellsApi cellsApi = new CellsApi(Environment.GetEnvironmentVariable("CellsCloudTestClientId"), Environment.GetEnvironmentVariable("CellsCloudTestClientSecret"));
	PostWorkbookCalculateFormulaRequest request = new PostWorkbookCalculateFormulaRequest { name = "Book1.xlsx", options = new Model.CalculationOptions { IgnoreError =true}, folder = "TestData/In" };
	cellsApi.PostWorkbookCalculateFormula(request);
	}
	}
	}
	// Obsolet
	//CellsApi instance = new CellsApi(clientId, clientSecret, apiVersion, testbaseurl);
	//string name = BOOK1;
	//CalculationOptions options = new CalculationOptions();
	//options.IgnoreError = true;
	//bool? ignoreError = true;
	//string folder = TEMPFOLDER;
	//instance.UploadFile(folder + @"\" + name, File.Open( @"C:\TestData\" +name));
	//var response = instance.CellsWorkbookPostWorkbookCalculateFormula(name, options, ignoreError, folder);
	//Assert.IsInstanceOf<CellsCloudResponse>(response, "response is CellsCloudResponse");
	//Assert.AreEqual(response.Code, 200);

view raw Examples-DotNet-CSharp-Cells-CalculateCellFormula-1.cs hosted with ❤ by GitHub

PHP

	// For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-php
	<?php
	require_once('vendor\autoload.php');
	use \Aspose\Cells\Cloud\Api\CellsApi;
	use \Aspose\Cells\Cloud\Request\PostWorksheetCellSetValueRequest;
	class Cell {

	public $instance;

	public function __construct() {
	$this->instance = new CellsApi(getenv("CellsCloudClientId"),getenv("CellsCloudClientSecret"),"v3.0",getenv("CellsCloudApiBaseUrl"));
	}

	public function postCalulateCellFormula() {
	$remoteFolder = "TestData/In";

	$localName = "Book1.xlsx";
	$remoteName = "Book1.xlsx";



	$request = new PostWorksheetCellSetValueRequest();
	$request->setName( $remoteName);
	$request->setSheetName( "Sheet1");
	$request->setCellName( "A1");
	$request->setValue( "now()");
	$request->setFolder( $remoteFolder);
	$request->setStorageName( "");
	$this->instance->postWorksheetCellSetValue($request);
	}
	}

	$instance = new Cell();
	$instance->postCalulateCellFormula();

	?>

view raw Examples-PHP-Cells-PostCalulateCellFormula-.php hosted with ❤ by GitHub

Ruby

	## For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-ruby
	require 'aspose_cells_cloud'

	class Cell

	include AsposeCellsCloud


	def initialize
	#Get client_id and client_secret from https://cloud.aspose.com
	@instance = AsposeCellsCloud::CellsApi.new($client_id,$client_secret,$api_version,$baseurl)
	end

	# Calculate cell's formula
	def post_calulate_cell_formula
	name = $BOOK1
	sheet_name = $SHEET1
	cell_name = 'A1'
	value = 1
	type = 'string'
	formula = nil
	folder = $TEMPFOLDER
	storage = nil
	result = @instance.upload_file( folder+"/"+name, ::File.open(File.expand_path("data/"+name),"r") {\|io\| io.read(io.size) })
	expect(result.uploaded.size).to be > 0
	result = @instance.cells_post_worksheet_cell_set_value(name, sheet_name, cell_name, {:value=>value, :type=>type, :folder=>folder})
	expect(result.code).to eql(200)
	end

	end

	cell = Cell.new()
	puts cell.post_calulate_cell_formula

view raw Examples-Ruby-Cells-post_calulate_cell_formula-.rb hosted with ❤ by GitHub

Node.js

	const { CellsApi, UploadFileRequest, Cells_PostWorksheetCellSetValueRequest } = require("asposecellscloud");
	const clientId = process.env.CellsCloudClientId;
	const clientSecret = process.env.CellsCloudClientSecret;
	const ApiURL = process.env.CellsCloudApiBaseUrl;
	const fs = require('fs');
	const path = require('path');
	const cellsApi = new CellsApi(clientId, clientSecret,"v3.0",ApiURL);
	const localPath = "D:/aspose-cells-cloud-node/TestData/"

	const filename = "Book1.xlsx";
	const data =fs.createReadStream(path.join(localPath, filename));

	const req = new UploadFileRequest({
	path: "Temp/" + filename,
	file: data
	});
	cellsApi.uploadFile(req)
	.then((result) => {
	//expect(result.body.uploaded.length).greaterThan(0);
	const req = new Cells_PostWorksheetCellSetValueRequest({
	name:filename,
	sheetName : "Sheet1",
	cellName : "A1",
	folder : "Temp",
	value : "1",
	type : "int",
	formula : null
	});
	cellsApi.cellsPostWorksheetCellSetValue(req)
	.then((result) => {
	req.value = "1";
	req.type = "String";
	cellsApi.cellsPostWorksheetCellSetValue(req)
	.then((result) => {
	req.value = "2018/10/09";
	req.type = "DateTime";
	req.formula = "=Now()";
	cellsApi.cellsPostWorksheetCellSetValue(req)
	.then((result) => {
	console.log("cellsPostWorksheetCellSetValue test done.")
	});
	});
	});
	})

view raw Examples-Node.js-SDK-Cells-CalculateCellFormula-1.js hosted with ❤ by GitHub

Perl

	## For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $options = AsposeCellsCloud::Object::CalculationOptions->new();
	$options->{ignore_error} = 'true' ;
	$options->{recursive} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorkbookCalculateFormulaRequest->new();
	$request->{name} = $remoteName;
	$request->{options} = $options;
	$request->{ignore_error} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $api->post_workbook_calculate_formula(request=> $request);

view raw Examples-Perl-Cells-CalculateCellFormula-1.pl hosted with ❤ by GitHub

Aspose.Cells.Cloud.SDK.Perl

view raw Aspose.Cells.Cloud.SDK.Perl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Background';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Background.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'BlankColumns';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-BlankColumns.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'BlankRows';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-BlankRows.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'chart';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Chart.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Comment';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Comment.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Content';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Content.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'DuplicateRows';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-DuplicateRows.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Formula';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Formula.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Hyperlink';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Hyperlink.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'ListObject';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-ListObject.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Picture';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Picture.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'PivotTable';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-PivotTable.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Shape';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Shape.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Style';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Style.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'Validation';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-Clear-Validation.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $objecttype = 'PivotTable';
	my $mapFiles = {};
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	my $result = $instance->post_clear_objects(request=> $request);

view raw Example-ClearObjects.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $request = AsposeCellsCloud::Request::DeleteWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $api->delete_worksheet_shape(request=> $request);

view raw Example-DeleteWorksheetShape.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $request = AsposeCellsCloud::Request::DeleteWorksheetShapesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $instance->delete_worksheet_shapes(request=> $request);

view raw Example-DeleteWorksheetShapes.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $roywangPFX = 'roywang.pfx';
	my $remoteName = 'Book1.xlsx';
	my $request = AsposeCellsCloud::Request::PostDigitalSignatureRequest->new();
	$request->{name} = $remoteName;
	$request->{digitalsignaturefile} = $remoteFolder . '/roywang.pfx';
	$request->{password} = '123456';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $instance->post_digital_signature(request=> $request);

view raw Example-DigitalSignature.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $request = AsposeCellsCloud::Request::GetWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $instance->get_worksheet_shape(request=> $request);

view raw Example-GetWorksheetShape.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $request = AsposeCellsCloud::Request::GetWorksheetShapesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $instance->get_worksheet_shapes(request=> $request);

view raw Example-GetWorksheetShapes.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $format = 'csv';
	my $mergeToOneSheet = 'true';
	my $mapFiles = {};
	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostMergeRequest->new();
	$request->{file} = $mapFiles;
	$request->{format} = $format;
	$request->{merge_to_one_sheet} = $mergeToOneSheet;
	my $result = $instance->post_merge(request=> $request);

view raw Example-PostMerge.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $dto = AsposeCellsCloud::Object::Shape->new();
	$dto->{lower_right_column} = 10 ;
	my $request = AsposeCellsCloud::Request::PostWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{dto} = $dto;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $api->post_worksheet_shape(request=> $request);

view raw Example-PostWorksheetShape.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $mapFiles = {};
	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostProtectRequest->new();
	$request->{file} = $mapFiles;
	$request->{password} = '123456';
	my $result = $api->post_protect(request=> $request);

view raw Example-Protect.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $shape_dto = AsposeCellsCloud::Object::Shape->new();
	my $request = AsposeCellsCloud::Request::PutWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shape_dto} = $shape_dto;
	$request->{drawing_type} = 'arc';
	$request->{upper_left_row} = 1;
	$request->{upper_left_column} = 1;
	$request->{top} = 10;
	$request->{left} = 10;
	$request->{width} = 100;
	$request->{height} = 100;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	my $result = $api->put_worksheet_shape(request=> $request);

view raw Example-PutWorksheetShape.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';
	my $remoteName = 'Book1.xlsx';
	my $format = 'csv';
	my $newfilename = 'dotNetSDK/OutResult/PostExcelSaveAs.csv';
	my $save_options = AsposeCellsCloud::Object::PdfSaveOptions->new();
	$save_options->{save_format} = $format ;
	my $request = AsposeCellsCloud::Request::PostWorkbookSaveAsRequest->new();
	$request->{name} = $remoteName;
	$request->{newfilename} = $newfilename;
	$request->{save_options} = $save_options;
	$request->{folder} = $remoteFolder;
	my $result = $api->post_workbook_save_as(request=> $request);

view raw Example-SaveAs.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $needUnlockXlsx = 'needUnlock.xlsx';
	my $mapFiles = {};
	$mapFiles->{$needUnlockXlsx}= "TestData/".$needUnlockXlsx ;
	my $request = AsposeCellsCloud::Request::PostUnlockRequest->new();
	$request->{file} = $mapFiles;
	$request->{password} = '123456';
	my $result = $api->post_unlock(request=> $request);

view raw Example-Unlock.pl hosted with ❤ by GitHub

	# For complete examples and data files, please go to https://github.com/aspose-cells-cloud/aspose-cells-cloud-perl/
	use strict;
	use warnings;
	use utf8;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;
	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'ProductClientId'}, client_secret => $ENV{'ProductClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';
	my $mapFiles = {};
	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;
	my $request = AsposeCellsCloud::Request::PostWatermarkRequest->new();
	$request->{file} = $mapFiles;
	$request->{text} = 'aspose.cells cloud sdk';
	$request->{color} = '#773322';
	my $result = $api->post_watermark(request=> $request);;

view raw Example-Watermark.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::CopyFileRequest->new();
	$request->{src_path} = $remoteFolder . '/' . $remoteName;
	$request->{dest_path} = 'OutResult/' . $remoteName;
	$request->{src_storage_name} = '';
	$request->{dest_storage_name} = '';
	$request->{version_id} = '';
	$instance->copy_file(request=> $request);

view raw Example_CopyFile.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::CopyFolderRequest->new();
	$request->{src_path} = $remoteFolder;
	$request->{dest_path} = 'OutResult/Create';
	$request->{src_storage_name} = '';
	$request->{dest_storage_name} = '';
	$instance->copy_folder(request=> $request);

view raw Example_CopyFolder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::CreateFolderRequest->new();
	$request->{path} = 'OutResult/NewFolder';
	$request->{storage_name} = '';
	$instance->create_folder(request=> $request);

view raw Example_CreateFolder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $encryption = AsposeCellsCloud::Object::WorkbookEncryptionRequest->new();
	$encryption->{password} = '123456' ;
	$encryption->{encryption_type} = 'XOR' ;
	$encryption->{key_length} = 128 ;

	my $request = AsposeCellsCloud::Request::DeleteDecryptWorkbookRequest->new();
	$request->{name} = $remoteName;
	$request->{encryption} = $encryption;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_decrypt_workbook(request=> $request);

view raw Example_DeleteDecryptWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteDocumentPropertiesRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_document_properties(request=> $request);

view raw Example_DeleteDocumentProperties.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteDocumentPropertyRequest->new();
	$request->{name} = $remoteName;
	$request->{property_name} = 'Author';
	$request->{type} = 'All';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_document_property(request=> $request);

view raw Example_DeleteDocumentProperty.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteDocumentUnProtectFromChangesRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_document_un_protect_from_changes(request=> $request);

view raw Example_DeleteDocumentUnProtectFromChanges.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteFileRequest->new();
	$request->{path} = $remoteFolder . '/' . $remoteName;
	$request->{storage_name} = '';
	$request->{version_id} = '';
	$instance->delete_file(request=> $request);

view raw Example_DeleteFile.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteFolderRequest->new();
	$request->{path} = 'OutResult/Create';
	$request->{storage_name} = '';
	$request->{recursive} = 'true';
	$instance->delete_folder(request=> $request);

view raw Example_DeleteFolder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteHeaderFooterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_header_footer(request=> $request);

view raw Example_DeleteHeaderFooter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteHorizontalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_horizontal_page_break(request=> $request);

view raw Example_DeleteHorizontalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteHorizontalPageBreaksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_horizontal_page_breaks(request=> $request);

view raw Example_DeleteHorizontalPageBreaks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';


	my $mapFiles = {};

	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::DeleteMetadataRequest->new();
	$request->{file} = $mapFiles;
	$request->{type} = 'all';
	$instance->delete_metadata(request=> $request);

view raw Example_DeleteMetadata.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @pivot_table_field_request_data = [];push (@pivot_table_field_request_data ,0 );
	my $pivot_table_field_request = AsposeCellsCloud::Object::PivotTableFieldRequest->new();
	$pivot_table_field_request->{data} = []; push ( @{$pivot_table_field_request->{data}}, 0 ); ;

	my $request = AsposeCellsCloud::Request::DeletePivotTableFieldRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{pivot_table_field_request} = $pivot_table_field_request;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_pivot_table_field(request=> $request);

view raw Example_DeletePivotTableField.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteUnProtectWorkbookRequest->new();
	$request->{name} = $remoteName;
	$request->{password} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_un_protect_workbook(request=> $request);

view raw Example_DeleteUnProtectWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $protect_parameter = AsposeCellsCloud::Object::ProtectSheetParameter->new();
	$protect_parameter->{protection_type} = 'ALL' ;
	$protect_parameter->{password} = '123' ;

	my $request = AsposeCellsCloud::Request::DeleteUnprotectWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{protect_parameter} = $protect_parameter;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_unprotect_worksheet(request=> $request);

view raw Example_DeleteUnprotectWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteVerticalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_vertical_page_break(request=> $request);

view raw Example_DeleteVerticalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteVerticalPageBreaksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_vertical_page_breaks(request=> $request);

view raw Example_DeleteVerticalPageBreaks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorkbookBackgroundRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_workbook_background(request=> $request);

view raw Example_DeleteWorkbookBackground.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorkbookNameRequest->new();
	$request->{name} = $remoteName;
	$request->{name_name} = 'Name_2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_workbook_name(request=> $request);

view raw Example_DeleteWorkbookName.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorkbookNamesRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_workbook_names(request=> $request);

view raw Example_DeleteWorkbookNames.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet(request=> $request);

view raw Example_DeleteWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetBackgroundRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_background(request=> $request);

view raw Example_DeleteWorksheetBackground.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetCellsRangeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = 'A1:C6';
	$request->{shift} = 'Up';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_cells_range(request=> $request);

view raw Example_DeleteWorksheetCellsRange.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetChartRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_chart(request=> $request);

view raw Example_DeleteWorksheetChart.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetChartLegendRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_chart_legend(request=> $request);

view raw Example_DeleteWorksheetChartLegend.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetChartsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_charts(request=> $request);

view raw Example_DeleteWorksheetCharts.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetChartTitleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_chart_title(request=> $request);

view raw Example_DeleteWorksheetChartTitle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column_index} = 1;
	$request->{columns} = 10;
	$request->{update_reference} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_columns(request=> $request);

view raw Example_DeleteWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetCommentRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'B3';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_comment(request=> $request);

view raw Example_DeleteWorksheetComment.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetCommentsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_comments(request=> $request);

view raw Example_DeleteWorksheetComments.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetConditionalFormattingRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_conditional_formatting(request=> $request);

view raw Example_DeleteWorksheetConditionalFormatting.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetConditionalFormattingAreaRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_row} = 1;
	$request->{start_column} = 1;
	$request->{total_rows} = 4;
	$request->{total_columns} = 6;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_conditional_formatting_area(request=> $request);

view raw Example_DeleteWorksheetConditionalFormattingArea.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetConditionalFormattingsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_conditional_formattings(request=> $request);

view raw Example_DeleteWorksheetConditionalFormattings.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetDateFilterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{field_index} = 0;
	$request->{date_time_grouping_type} = 'Year';
	$request->{year} = 1920;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_date_filter(request=> $request);

view raw Example_DeleteWorksheetDateFilter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetFilterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{field_index} = 0;
	$request->{criteria} = 'year';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_filter(request=> $request);

view raw Example_DeleteWorksheetFilter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetFreezePanesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row} = 1;
	$request->{column} = 1;
	$request->{freezed_rows} = 4;
	$request->{freezed_columns} = 5;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_freeze_panes(request=> $request);

view raw Example_DeleteWorksheetFreezePanes.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetHyperlinkRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{hyperlink_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_hyperlink(request=> $request);

view raw Example_DeleteWorksheetHyperlink.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetHyperlinksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_hyperlinks(request=> $request);

view raw Example_DeleteWorksheetHyperlinks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetListObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_list_object(request=> $request);

view raw Example_DeleteWorksheetListObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetListObjectsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_list_objects(request=> $request);

view raw Example_DeleteWorksheetListObjects.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetOleObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{ole_object_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_ole_object(request=> $request);

view raw Example_DeleteWorksheetOleObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetOleObjectsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_ole_objects(request=> $request);

view raw Example_DeleteWorksheetOleObjects.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPictureRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{picture_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_picture(request=> $request);

view raw Example_DeleteWorksheetPicture.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPicturesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_pictures(request=> $request);

view raw Example_DeleteWorksheetPictures.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPivotTableRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_pivot_table(request=> $request);

view raw Example_DeleteWorksheetPivotTable.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPivotTableFilterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet3';
	$request->{pivot_table_index} = 0;
	$request->{field_index} = 0;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_pivot_table_filter(request=> $request);

view raw Example_DeleteWorksheetPivotTableFilter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPivotTableFiltersRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet3';
	$request->{pivot_table_index} = 0;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_pivot_table_filters(request=> $request);

view raw Example_DeleteWorksheetPivotTableFilters.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetPivotTablesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_pivot_tables(request=> $request);

view raw Example_DeleteWorksheetPivotTables.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetRowRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_row(request=> $request);

view raw Example_DeleteWorksheetRow.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{startrow} = 1;
	$request->{total_rows} = 10;
	$request->{update_reference} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_rows(request=> $request);

view raw Example_DeleteWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $match_condition = AsposeCellsCloud::Object::MatchConditionRequest->new();
	$match_condition->{regex_pattern} = '{*}' ;

	my $request = AsposeCellsCloud::Request::DeleteWorksheetsRequest->new();
	$request->{name} = $remoteName;
	$request->{match_condition} = $match_condition;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheets(request=> $request);

view raw Example_DeleteWorksheets.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_shape(request=> $request);

view raw Example_DeleteWorksheetShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetShapesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_shapes(request=> $request);

view raw Example_DeleteWorksheetShapes.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetSparklineGroupRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{sparkline_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_sparkline_group(request=> $request);

view raw Example_DeleteWorksheetSparklineGroup.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetSparklineGroupsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_sparkline_groups(request=> $request);

view raw Example_DeleteWorksheetSparklineGroups.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetValidationRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{validation_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_validation(request=> $request);

view raw Example_DeleteWorksheetValidation.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DeleteWorksheetValidationsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->delete_worksheet_validations(request=> $request);

view raw Example_DeleteWorksheetValidations.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::DownloadFileRequest->new();
	$request->{path} = $remoteFolder . '/' . $remoteName;
	$request->{storage_name} = '';
	$request->{version_id} = '';
	$instance->download_file(request=> $request);

view raw Example_DownloadFile.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetCellHtmlStringRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_cell_html_string(request=> $request);

view raw Example_GetCellHtmlString.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetCellsCloudServicesHealthCheckRequest->new();
	$instance->get_cells_cloud_services_health_check(request=> $request);

view raw Example_GetCellsCloudServicesHealthCheck.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetCellsCloudServiceStatusRequest->new();
	$instance->get_cells_cloud_service_status(request=> $request);

view raw Example_GetCellsCloudServiceStatus.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetChartAreaRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_chart_area(request=> $request);

view raw Example_GetChartArea.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetChartAreaBorderRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_chart_area_border(request=> $request);

view raw Example_GetChartAreaBorder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetChartAreaFillFormatRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_chart_area_fill_format(request=> $request);

view raw Example_GetChartAreaFillFormat.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetDiscUsageRequest->new();
	$request->{storage_name} = '';
	$instance->get_disc_usage(request=> $request);

view raw Example_GetDiscUsage.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetDocumentPropertiesRequest->new();
	$request->{name} = $remoteName;
	$request->{type} = 'All';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_document_properties(request=> $request);

view raw Example_GetDocumentProperties.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetDocumentPropertyRequest->new();
	$request->{name} = $remoteName;
	$request->{property_name} = 'Author';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_document_property(request=> $request);

view raw Example_GetDocumentProperty.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetFilesListRequest->new();
	$request->{path} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_files_list(request=> $request);

view raw Example_GetFilesList.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetFileVersionsRequest->new();
	$request->{path} = 'TestData/In/Book1.xlsx';
	$request->{storage_name} = '';
	$instance->get_file_versions(request=> $request);

view raw Example_GetFileVersions.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetFooterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_footer(request=> $request);

view raw Example_GetFooter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetHeaderRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_header(request=> $request);

view raw Example_GetHeader.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetHorizontalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_horizontal_page_break(request=> $request);

view raw Example_GetHorizontalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetHorizontalPageBreaksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_horizontal_page_breaks(request=> $request);

view raw Example_GetHorizontalPageBreaks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';


	my $mapFiles = {};

	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::GetMetadataRequest->new();
	$request->{file} = $mapFiles;
	$request->{type} = 'all';
	$instance->get_metadata(request=> $request);

view raw Example_GetMetadata.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetNamedRangesRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_named_ranges(request=> $request);

view raw Example_GetNamedRanges.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetNamedRangeValueRequest->new();
	$request->{name} = $remoteName;
	$request->{namerange} = 'Name_2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_named_range_value(request=> $request);

view raw Example_GetNamedRangeValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetPageCountRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_page_count(request=> $request);

view raw Example_GetPageCount.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetPageSetupRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_page_setup(request=> $request);

view raw Example_GetPageSetup.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetPivotTableFieldRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_pivot_table_field(request=> $request);

view raw Example_GetPivotTableField.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetVerticalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_vertical_page_break(request=> $request);

view raw Example_GetVerticalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetVerticalPageBreaksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_vertical_page_breaks(request=> $request);

view raw Example_GetVerticalPageBreaks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $format = 'csv';


	my $request = AsposeCellsCloud::Request::GetWorkbookRequest->new();
	$request->{name} = $remoteName;
	$request->{format} = $format;
	$request->{folder} = $remoteFolder;
	$instance->get_workbook(request=> $request);

view raw Example_GetWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookDefaultStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_default_style(request=> $request);

view raw Example_GetWorkbookDefaultStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookNameRequest->new();
	$request->{name} = $remoteName;
	$request->{name_name} = 'Name_2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_name(request=> $request);

view raw Example_GetWorkbookName.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookNamesRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_names(request=> $request);

view raw Example_GetWorkbookNames.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookNameValueRequest->new();
	$request->{name} = $remoteName;
	$request->{name_name} = 'Name_2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_name_value(request=> $request);

view raw Example_GetWorkbookNameValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookSettingsRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_settings(request=> $request);

view raw Example_GetWorkbookSettings.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorkbookTextItemsRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_workbook_text_items(request=> $request);

view raw Example_GetWorkbookTextItems.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetAutoFilterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_auto_filter(request=> $request);

view raw Example_GetWorksheetAutoFilter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCalculateFormulaRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{formula} = '=NOW()';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_calculate_formula(request=> $request);

view raw Example_GetWorksheetCalculateFormula.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCellRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_or_method_name} = 'A1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_cell(request=> $request);

view raw Example_GetWorksheetCell.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCellsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{offest} = 1;
	$request->{count} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_cells(request=> $request);

view raw Example_GetWorksheetCells.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCellsRangeValueRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{namerange} = 'Name_2';
	$request->{first_row} = 0;
	$request->{first_column} = 0;
	$request->{row_count} = 3;
	$request->{column_count} = 2;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_cells_range_value(request=> $request);

view raw Example_GetWorksheetCellsRangeValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCellStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_cell_style(request=> $request);

view raw Example_GetWorksheetCellStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetChartRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_number} = 0;
	$request->{format} = 'png';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_chart(request=> $request);

view raw Example_GetWorksheetChart.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetChartLegendRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_chart_legend(request=> $request);

view raw Example_GetWorksheetChartLegend.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetChartsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_charts(request=> $request);

view raw Example_GetWorksheetCharts.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetChartTitleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_chart_title(request=> $request);

view raw Example_GetWorksheetChartTitle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetColumnRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column_index} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_column(request=> $request);

view raw Example_GetWorksheetColumn.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{offset} = 1;
	$request->{count} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_columns(request=> $request);

view raw Example_GetWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCommentRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'B3';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_comment(request=> $request);

view raw Example_GetWorksheetComment.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetCommentsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_comments(request=> $request);

view raw Example_GetWorksheetComments.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetConditionalFormattingRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_conditional_formatting(request=> $request);

view raw Example_GetWorksheetConditionalFormatting.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetConditionalFormattingsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_conditional_formattings(request=> $request);

view raw Example_GetWorksheetConditionalFormattings.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetHyperlinkRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{hyperlink_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_hyperlink(request=> $request);

view raw Example_GetWorksheetHyperlink.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetHyperlinksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_hyperlinks(request=> $request);

view raw Example_GetWorksheetHyperlinks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetListObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{listobjectindex} = 0;
	$request->{format} = 'pdf';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_list_object(request=> $request);

view raw Example_GetWorksheetListObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetListObjectsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_list_objects(request=> $request);

view raw Example_GetWorksheetListObjects.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetMergedCellRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{merged_cell_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_merged_cell(request=> $request);

view raw Example_GetWorksheetMergedCell.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetMergedCellsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_merged_cells(request=> $request);

view raw Example_GetWorksheetMergedCells.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetOleObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{object_number} = 0;
	$request->{format} = 'png';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_ole_object(request=> $request);

view raw Example_GetWorksheetOleObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetOleObjectsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_ole_objects(request=> $request);

view raw Example_GetWorksheetOleObjects.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPageCountRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_page_count(request=> $request);

view raw Example_GetWorksheetPageCount.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPicturesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_pictures(request=> $request);

view raw Example_GetWorksheetPictures.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPictureWithFormatRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{picture_number} = 0;
	$request->{format} = 'png';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_picture_with_format(request=> $request);

view raw Example_GetWorksheetPictureWithFormat.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPivotTableRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivottable_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_pivot_table(request=> $request);

view raw Example_GetWorksheetPivotTable.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPivotTableFilterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet3';
	$request->{pivot_table_index} = 0;
	$request->{filter_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_pivot_table_filter(request=> $request);

view raw Example_GetWorksheetPivotTableFilter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPivotTableFiltersRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_pivot_table_filters(request=> $request);

view raw Example_GetWorksheetPivotTableFilters.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetPivotTablesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_pivot_tables(request=> $request);

view raw Example_GetWorksheetPivotTables.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetRowRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_row(request=> $request);

view raw Example_GetWorksheetRow.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{offset} = 1;
	$request->{count} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_rows(request=> $request);

view raw Example_GetWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetsRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheets(request=> $request);

view raw Example_GetWorksheets.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_shape(request=> $request);

view raw Example_GetWorksheetShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetShapesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_shapes(request=> $request);

view raw Example_GetWorksheetShapes.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetSparklineGroupRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{sparkline_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_sparkline_group(request=> $request);

view raw Example_GetWorksheetSparklineGroup.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetSparklineGroupsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_sparkline_groups(request=> $request);

view raw Example_GetWorksheetSparklineGroups.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetTextItemsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_text_items(request=> $request);

view raw Example_GetWorksheetTextItems.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetValidationRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{validation_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_validation(request=> $request);

view raw Example_GetWorksheetValidation.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetValidationsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_validations(request=> $request);

view raw Example_GetWorksheetValidations.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::GetWorksheetWithFormatRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{format} = 'png';
	$request->{page_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->get_worksheet_with_format(request=> $request);

view raw Example_GetWorksheetWithFormat.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::MoveFileRequest->new();
	$request->{src_path} = $remoteFolder . '/' . $remoteName;
	$request->{dest_path} = 'OutResult/' . $remoteName;
	$request->{src_storage_name} = '';
	$request->{dest_storage_name} = '';
	$request->{version_id} = '';
	$instance->move_file(request=> $request);

view raw Example_MoveFile.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::MoveFolderRequest->new();
	$request->{src_path} = 'OutResult/Create';
	$request->{dest_path} = 'OutResult/Move';
	$request->{src_storage_name} = '';
	$request->{dest_storage_name} = '';
	$instance->move_folder(request=> $request);

view raw Example_MoveFolder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::ObjectExistsRequest->new();
	$request->{path} = 'TestData/In/Book1.xlsx';
	$request->{storage_name} = '';
	$request->{version_id} = '';
	$instance->object_exists(request=> $request);

view raw Example_ObjectExists.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $format = 'csv';

	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostAssembleRequest->new();
	$request->{file} = $mapFiles;
	$request->{datasource} = 'ds';
	$request->{out_format} = $format;
	$instance->post_assemble(request=> $request);

view raw Example_PostAssemble.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostAutofitWorkbookColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{start_column} = 1;
	$request->{end_column} = 20;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_autofit_workbook_columns(request=> $request);

view raw Example_PostAutofitWorkbookColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostAutofitWorkbookRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{start_row} = 1;
	$request->{end_row} = 100;
	$request->{only_auto} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_autofit_workbook_rows(request=> $request);

view raw Example_PostAutofitWorkbookRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostAutofitWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_column} = 1;
	$request->{end_column} = 9;
	$request->{only_auto} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_autofit_worksheet_columns(request=> $request);

view raw Example_PostAutofitWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostAutofitWorksheetRowRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{first_column} = 1;
	$request->{last_column} = 8;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_autofit_worksheet_row(request=> $request);

view raw Example_PostAutofitWorksheetRow.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostAutofitWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_row} = 1;
	$request->{end_row} = 9;
	$request->{only_auto} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_autofit_worksheet_rows(request=> $request);

view raw Example_PostAutofitWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localBook1 = 'Book1.xlsx';
	my $remoteBook1 = 'Book1.xlsx';
	my $localMyDoc = 'myDocument.xlsx';
	my $remoteMyDoc = 'myDocument.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localBook1 => $localBook1 } ,'path'=>$remoteFolder . '/' . $remoteBook1 );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localMyDoc => $localMyDoc } ,'path'=>$remoteFolder . '/' . $remoteMyDoc );

	my $batch_convert_request_match_condition = AsposeCellsCloud::Object::MatchConditionRequest->new();
	$batch_convert_request_match_condition->{regex_pattern} = '(^Book)(.+)(xlsx$)' ;
	my $batch_convert_request = AsposeCellsCloud::Object::BatchConvertRequest->new();
	$batch_convert_request->{source_folder} = $remoteFolder ;
	$batch_convert_request->{format} = 'pdf' ;
	$batch_convert_request->{out_folder} = 'OutResult' ;
	$batch_convert_request->{match_condition} = $batch_convert_request_match_condition ;

	my $request = AsposeCellsCloud::Request::PostBatchConvertRequest->new();
	$request->{batch_convert_request} = $batch_convert_request;
	$instance->post_batch_convert(request=> $request);

view raw Example_PostBatchConvert.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localBook1 = 'Book1.xlsx';
	my $remoteBook1 = 'Book1.xlsx';
	my $localMyDoc = 'myDocument.xlsx';
	my $remoteMyDoc = 'myDocument.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localBook1 => $localBook1 } ,'path'=>$remoteFolder . '/' . $remoteBook1 );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localMyDoc => $localMyDoc } ,'path'=>$remoteFolder . '/' . $remoteMyDoc );

	my $batch_lock_request_match_condition = AsposeCellsCloud::Object::MatchConditionRequest->new();
	$batch_lock_request_match_condition->{regex_pattern} = '(^Book)(.+)(xlsx$)' ;
	my $batch_lock_request = AsposeCellsCloud::Object::BatchLockRequest->new();
	$batch_lock_request->{source_folder} = $remoteFolder ;
	$batch_lock_request->{password} = '123456' ;
	$batch_lock_request->{out_folder} = 'OutResult' ;
	$batch_lock_request->{match_condition} = $batch_lock_request_match_condition ;

	my $request = AsposeCellsCloud::Request::PostBatchLockRequest->new();
	$request->{batch_lock_request} = $batch_lock_request;
	$instance->post_batch_lock(request=> $request);

view raw Example_PostBatchLock.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localBook1 = 'Book1.xlsx';
	my $remoteBook1 = 'Book1.xlsx';
	my $localMyDoc = 'myDocument.xlsx';
	my $remoteMyDoc = 'myDocument.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localBook1 => $localBook1 } ,'path'=>$remoteFolder . '/' . $remoteBook1 );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localMyDoc => $localMyDoc } ,'path'=>$remoteFolder . '/' . $remoteMyDoc );

	my $batch_protect_request_match_condition = AsposeCellsCloud::Object::MatchConditionRequest->new();
	$batch_protect_request_match_condition->{regex_pattern} = '(^Book)(.+)(xlsx$)' ;
	my $batch_protect_request = AsposeCellsCloud::Object::BatchProtectRequest->new();
	$batch_protect_request->{source_folder} = $remoteFolder ;
	$batch_protect_request->{protection_type} = 'All' ;
	$batch_protect_request->{password} = '123456' ;
	$batch_protect_request->{out_folder} = 'OutResult' ;
	$batch_protect_request->{match_condition} = $batch_protect_request_match_condition ;

	my $request = AsposeCellsCloud::Request::PostBatchProtectRequest->new();
	$request->{batch_protect_request} = $batch_protect_request;
	$instance->post_batch_protect(request=> $request);

view raw Example_PostBatchProtect.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localBook1 = 'Book1.xlsx';
	my $remoteBook1 = 'Book1.xlsx';
	my $localMyDoc = 'myDocument.xlsx';
	my $remoteMyDoc = 'myDocument.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localBook1 => $localBook1 } ,'path'=>$remoteFolder . '/' . $remoteBook1 );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localMyDoc => $localMyDoc } ,'path'=>$remoteFolder . '/' . $remoteMyDoc );

	my $batch_lock_request_match_condition = AsposeCellsCloud::Object::MatchConditionRequest->new();
	$batch_lock_request_match_condition->{regex_pattern} = '(^Book)(.+)(xlsx$)' ;
	my $batch_lock_request = AsposeCellsCloud::Object::BatchLockRequest->new();
	$batch_lock_request->{source_folder} = $remoteFolder ;
	$batch_lock_request->{password} = '123456' ;
	$batch_lock_request->{out_folder} = 'OutResult' ;
	$batch_lock_request->{match_condition} = $batch_lock_request_match_condition ;

	my $request = AsposeCellsCloud::Request::PostBatchUnlockRequest->new();
	$request->{batch_lock_request} = $batch_lock_request;
	$instance->post_batch_unlock(request=> $request);

view raw Example_PostBatchUnlock.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $options = AsposeCellsCloud::Object::CalculationOptions->new();
	$options->{recursive} = 'true' ;
	$options->{ignore_error} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostCellCalculateRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{options} = $options;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_cell_calculate(request=> $request);

view raw Example_PostCellCalculate.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $optionsvalue0_font = AsposeCellsCloud::Object::Font->new();
	$optionsvalue0_font->{is_bold} = 'true' ;
	$optionsvalue0_font->{size} = 16 ;
	my $optionsvalue0 = AsposeCellsCloud::Object::FontSetting->new();
	$optionsvalue0->{length} = 5 ;
	$optionsvalue0->{start_index} = 0 ;
	$optionsvalue0->{font} = $optionsvalue0_font ;
	my @options = [];push (@options ,$optionsvalue0 );

	my $request = AsposeCellsCloud::Request::PostCellCharactersRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'E36';
	$request->{options} = []; push ( @{$request->{options}}, $optionsvalue0 );;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_cell_characters(request=> $request);

view raw Example_PostCellCharacters.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostClearContentsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = 'A1:C10';
	$request->{start_row} = 1;
	$request->{start_column} = 1;
	$request->{end_row} = 3;
	$request->{end_column} = 3;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_clear_contents(request=> $request);

view raw Example_PostClearContents.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostClearFormatsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = 'A1:C10';
	$request->{start_row} = 1;
	$request->{start_column} = 1;
	$request->{end_row} = 3;
	$request->{end_column} = 3;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_clear_formats(request=> $request);

view raw Example_PostClearFormats.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $objecttype = 'chart';

	my $mapFiles = {};

	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostClearObjectsRequest->new();
	$request->{file} = $mapFiles;
	$request->{objecttype} = $objecttype;
	$instance->post_clear_objects(request=> $request);

view raw Example_PostClearObjects.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostColumnStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column_index} = 1;
	$request->{style} = $style;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_column_style(request=> $request);

view raw Example_PostColumnStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $compressLevel = 50;

	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostCompressRequest->new();
	$request->{file} = $mapFiles;
	$request->{compress_level} = $compressLevel;
	$instance->post_compress(request=> $request);

view raw Example_PostCompress.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostCopyCellIntoCellRequest->new();
	$request->{name} = $remoteName;
	$request->{dest_cell_name} = 'C1';
	$request->{sheet_name} = 'Sheet1';
	$request->{worksheet} = 'Sheet2';
	$request->{cellname} = 'A1';
	$request->{row} = 1;
	$request->{column} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_copy_cell_into_cell(request=> $request);

view raw Example_PostCopyCellIntoCell.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $options = AsposeCellsCloud::Object::CopyOptions->new();
	$options->{column_character_width} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostCopyWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet15';
	$request->{source_sheet} = 'Sheet6';
	$request->{options} = $options;
	$request->{source_workbook} = '';
	$request->{source_folder} = '';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_copy_worksheet(request=> $request);

view raw Example_PostCopyWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostCopyWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{source_column_index} = 1;
	$request->{destination_column_index} = 19;
	$request->{column_number} = 8;
	$request->{worksheet} = 'Sheet2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_copy_worksheet_columns(request=> $request);

view raw Example_PostCopyWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostCopyWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{source_row_index} = 1;
	$request->{destination_row_index} = 12;
	$request->{row_number} = 5;
	$request->{worksheet} = 'Sheet2';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_copy_worksheet_rows(request=> $request);

view raw Example_PostCopyWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $roywangPFX = 'roywang.pfx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $roywangPFX => $roywangPFX } ,'path'=>$remoteFolder . '/roywang.pfx' );


	my $request = AsposeCellsCloud::Request::PostDigitalSignatureRequest->new();
	$request->{name} = $remoteName;
	$request->{digitalsignaturefile} = $remoteFolder . '/roywang.pfx';
	$request->{password} = '123456';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_digital_signature(request=> $request);

view raw Example_PostDigitalSignature.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $encryption = AsposeCellsCloud::Object::WorkbookEncryptionRequest->new();
	$encryption->{password} = '123456' ;
	$encryption->{encryption_type} = 'XOR' ;
	$encryption->{key_length} = 128 ;

	my $request = AsposeCellsCloud::Request::PostEncryptWorkbookRequest->new();
	$request->{name} = $remoteName;
	$request->{encryption} = $encryption;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_encrypt_workbook(request=> $request);

view raw Example_PostEncryptWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $book1Xlsx = 'Book1.xlsx';


	my $format = 'csv';
	my $objectType = 'workbook';

	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::PostExportRequest->new();
	$request->{file} = $mapFiles;
	$request->{object_type} = $objectType;
	$request->{format} = $format;
	$instance->post_export(request=> $request);

view raw Example_PostExport.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostFitTallToPagesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_fit_tall_to_pages(request=> $request);

view raw Example_PostFitTallToPages.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostFitWideToPagesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_fit_wide_to_pages(request=> $request);

view raw Example_PostFitWideToPages.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostFooterRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{section} = 1;
	$request->{script} = 'add footer script';
	$request->{is_first_page} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_footer(request=> $request);

view raw Example_PostFooter.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostGroupWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{first_index} = 1;
	$request->{last_index} = 9;
	$request->{hide} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_group_worksheet_columns(request=> $request);

view raw Example_PostGroupWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostGroupWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{first_index} = 1;
	$request->{last_index} = 9;
	$request->{hide} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_group_worksheet_rows(request=> $request);

view raw Example_PostGroupWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostHeaderRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{section} = 1;
	$request->{script} = 'Update add header';
	$request->{is_first_page} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_header(request=> $request);

view raw Example_PostHeader.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostHideWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_column} = 1;
	$request->{total_columns} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_hide_worksheet_columns(request=> $request);

view raw Example_PostHideWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostHideWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{startrow} = 1;
	$request->{total_rows} = 6;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_hide_worksheet_rows(request=> $request);

view raw Example_PostHideWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @import_option_data = [];push (@import_option_data ,1 );
	push (@import_option_data ,2 );
	push (@import_option_data ,3 );
	push (@import_option_data ,4 );
	my $import_option = AsposeCellsCloud::Object::ImportIntArrayOption->new();
	$import_option->{destination_worksheet} = 'Sheet1' ;
	$import_option->{first_column} = 1 ;
	$import_option->{first_row} = 3 ;
	$import_option->{import_data_type} = 'IntArray' ;
	$import_option->{is_insert} = 'true' ;
	$import_option->{is_vertical} = 'true' ;
	$import_option->{data} = []; push ( @{$import_option->{data}}, 1 );
	push ( @{$import_option->{data}}, 2 );
	push ( @{$import_option->{data}}, 3 );
	push ( @{$import_option->{data}}, 4 ); ;

	my $request = AsposeCellsCloud::Request::PostImportDataRequest->new();
	$request->{name} = $remoteName;
	$request->{import_option} = $import_option;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_import_data(request=> $request);

view raw Example_PostImportData.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $format = 'csv';
	my $mergeToOneSheet = 'true';

	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostMergeRequest->new();
	$request->{file} = $mapFiles;
	$request->{out_format} = $format;
	$request->{merge_to_one_sheet} = $mergeToOneSheet;
	$instance->post_merge(request=> $request);

view raw Example_PostMerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';


	my $mapFiles = {};

	my $cells_documentscells_document0 = AsposeCellsCloud::Object::CellsDocumentProperty->new();
	$cells_documentscells_document0->{name} = 'Author' ;
	$cells_documentscells_document0->{value} = 'roy.wang' ;
	my @cells_documents = [];push (@cells_documents ,$cells_documentscells_document0 );
	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::PostMetadataRequest->new();
	$request->{file} = $mapFiles;
	$request->{cells_documents} = []; push ( @{$request->{cells_documents}}, $cells_documentscells_document0 );;
	$instance->post_metadata(request=> $request);

view raw Example_PostMetadata.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $moving = AsposeCellsCloud::Object::WorksheetMovingRequest->new();
	$moving->{destination_worksheet} = 'Sheet4' ;
	$moving->{position} = 'After' ;

	my $request = AsposeCellsCloud::Request::PostMoveWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{moving} = $moving;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_move_worksheet(request=> $request);

view raw Example_PostMoveWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $page_setup = AsposeCellsCloud::Object::PageSetup->new();
	$page_setup->{black_and_white} = 'true' ;
	$page_setup->{center_horizontally} = 'true' ;
	$page_setup->{center_vertically} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostPageSetupRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{page_setup} = $page_setup;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_page_setup(request=> $request);

view raw Example_PostPageSetup.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostPivotTableCellStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{column} = 1;
	$request->{row} = 1;
	$request->{style} = $style;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_cell_style(request=> $request);

view raw Example_PostPivotTableCellStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostPivotTableFieldHideItemRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{field_index} = 0;
	$request->{item_index} = 1;
	$request->{is_hide} = 'true';
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_field_hide_item(request=> $request);

view raw Example_PostPivotTableFieldHideItem.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostPivotTableFieldMoveToRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{field_index} = 0;
	$request->{from} = 'Row';
	$request->{to} = 'Column';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_field_move_to(request=> $request);

view raw Example_PostPivotTableFieldMoveTo.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostPivotTableStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{style} = $style;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_style(request=> $request);

view raw Example_PostPivotTableStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $pivot_field = AsposeCellsCloud::Object::PivotField->new();
	$pivot_field->{show_compact} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostPivotTableUpdatePivotFieldRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{pivot_field} = $pivot_field;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_update_pivot_field(request=> $request);

view raw Example_PostPivotTableUpdatePivotField.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $pivot_field = AsposeCellsCloud::Object::PivotField->new();
	$pivot_field->{show_compact} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostPivotTableUpdatePivotFieldsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{pivot_field} = $pivot_field;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_pivot_table_update_pivot_fields(request=> $request);

view raw Example_PostPivotTableUpdatePivotFields.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $mapFiles = {};

	my $protect_workbook_request = AsposeCellsCloud::Object::ProtectWorkbookRequest->new();
	$protect_workbook_request->{aways_open_read_only} = 'true' ;
	$protect_workbook_request->{encrypt_with_password} = '123456' ;
	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostProtectRequest->new();
	$request->{file} = $mapFiles;
	$request->{protect_workbook_request} = $protect_workbook_request;
	$request->{password} = '123456';
	$instance->post_protect(request=> $request);

view raw Example_PostProtect.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $protect_workbook_request = AsposeCellsCloud::Object::ProtectWorkbookRequest->new();
	$protect_workbook_request->{encrypt_with_password} = '123456' ;
	$protect_workbook_request->{protect_workbook_structure} = 'ALL' ;

	my $request = AsposeCellsCloud::Request::PostProtectWorkbookRequest->new();
	$request->{name} = $remoteName;
	$request->{protect_workbook_request} = $protect_workbook_request;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_protect_workbook(request=> $request);

view raw Example_PostProtectWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostRenameWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet5';
	$request->{newname} = 'Sheet55';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_rename_worksheet(request=> $request);

view raw Example_PostRenameWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';


	my $format = 'xlsx';

	my $mapFiles = {};

	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::PostRepairRequest->new();
	$request->{file} = $mapFiles;
	$request->{out_format} = $format;
	$instance->post_repair(request=> $request);

view raw Example_PostRepair.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostReplaceRequest->new();
	$request->{file} = $mapFiles;
	$request->{text} = '12';
	$request->{newtext} = 'newtext';
	$instance->post_replace(request=> $request);

view raw Example_PostReplace.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $book1Xlsx = 'Book1.xlsx';


	my $rotateType = 'rows';
	my $format = 'pdf';

	my $mapFiles = {};

	$mapFiles->{$book1Xlsx}= "TestData/".$book1Xlsx ;

	my $request = AsposeCellsCloud::Request::PostReverseRequest->new();
	$request->{file} = $mapFiles;
	$request->{rotate_type} = $rotateType;
	$request->{out_format} = $format;
	$instance->post_reverse(request=> $request);

view raw Example_PostReverse.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostRowStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{style} = $style;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_row_style(request=> $request);

view raw Example_PostRowStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostSearchRequest->new();
	$request->{file} = $mapFiles;
	$request->{text} = '12';
	$instance->post_search(request=> $request);

view raw Example_PostSearch.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostSetCellHtmlStringRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_set_cell_html_string(request=> $request);

view raw Example_PostSetCellHtmlString.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostSetCellRangeValueRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cellarea} = 'A1:C10';
	$request->{value} = 'Test';
	$request->{type} = 'string';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_set_cell_range_value(request=> $request);

view raw Example_PostSetCellRangeValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostSetWorksheetColumnWidthRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column_index} = 1;
	$request->{width} = 10.9;
	$request->{count} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_set_worksheet_column_width(request=> $request);

view raw Example_PostSetWorksheetColumnWidth.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $outFormat = 'csv';

	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostSplitRequest->new();
	$request->{file} = $mapFiles;
	$request->{out_format} = $outFormat;
	$instance->post_split(request=> $request);

view raw Example_PostSplit.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUngroupWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{first_index} = 1;
	$request->{last_index} = 9;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_ungroup_worksheet_columns(request=> $request);

view raw Example_PostUngroupWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUngroupWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{first_index} = 1;
	$request->{last_index} = 9;
	$request->{is_all} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_ungroup_worksheet_rows(request=> $request);

view raw Example_PostUngroupWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUnhideWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_column} = 1;
	$request->{total_columns} = 10;
	$request->{width} = 10.9;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_unhide_worksheet_columns(request=> $request);

view raw Example_PostUnhideWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUnhideWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{startrow} = 1;
	$request->{total_rows} = 8;
	$request->{height} = 10.9;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_unhide_worksheet_rows(request=> $request);

view raw Example_PostUnhideWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $needUnlockXlsx = 'needUnlock.xlsx';


	my $mapFiles = {};

	$mapFiles->{$needUnlockXlsx}= "TestData/".$needUnlockXlsx ;

	my $request = AsposeCellsCloud::Request::PostUnlockRequest->new();
	$request->{file} = $mapFiles;
	$request->{password} = '123456';
	$instance->post_unlock(request=> $request);

view raw Example_PostUnlock.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetCellStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{style} = $style;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_cell_style(request=> $request);

view raw Example_PostUpdateWorksheetCellStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $ole = AsposeCellsCloud::Object::OleObject->new();
	$ole->{left} = 10 ;
	$ole->{right} = 10 ;
	$ole->{height} = 90 ;
	$ole->{width} = 78 ;

	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetOleObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{ole_object_index} = 0;
	$request->{ole} = $ole;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_ole_object(request=> $request);

view raw Example_PostUpdateWorksheetOleObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $sheet = AsposeCellsCloud::Object::Worksheet->new();
	$sheet->{name} = 'sheet65' ;
	$sheet->{is_gridlines_visible} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetPropertyRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet5';
	$request->{sheet} = $sheet;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_property(request=> $request);

view raw Example_PostUpdateWorksheetProperty.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $style_font = AsposeCellsCloud::Object::Font->new();
	$style_font->{size} = 16 ;
	my $style = AsposeCellsCloud::Object::Style->new();
	$style->{font} = $style_font ;

	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetRangeStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = 'A1:C10';
	$request->{style} = $style;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_range_style(request=> $request);

view raw Example_PostUpdateWorksheetRangeStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetRowRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{height} = 10.8;
	$request->{count} = 9;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_row(request=> $request);

view raw Example_PostUpdateWorksheetRow.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostUpdateWorksheetZoomRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{value} = 90;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_update_worksheet_zoom(request=> $request);

view raw Example_PostUpdateWorksheetZoom.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));


	my $assemblyTestXlsx = 'assemblytest.xlsx';
	my $dataSourceXlsx = 'datasource.xlsx';


	my $mapFiles = {};

	$mapFiles->{$assemblyTestXlsx}= "TestData/".$assemblyTestXlsx ;
	$mapFiles->{$dataSourceXlsx}= "TestData/".$dataSourceXlsx ;

	my $request = AsposeCellsCloud::Request::PostWatermarkRequest->new();
	$request->{file} = $mapFiles;
	$request->{text} = 'aspose.cells cloud sdk';
	$request->{color} = '#773322';
	$instance->post_watermark(request=> $request);

view raw Example_PostWatermark.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $options = AsposeCellsCloud::Object::CalculationOptions->new();
	$options->{ignore_error} = 'true' ;
	$options->{recursive} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorkbookCalculateFormulaRequest->new();
	$request->{name} = $remoteName;
	$request->{options} = $options;
	$request->{ignore_error} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_calculate_formula(request=> $request);

view raw Example_PostWorkbookCalculateFormula.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'BookCsvDuplicateData.csv';
	my $remoteName = 'BookCsvDuplicateData.csv';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $data_cleansing_data_fill_data_fill_default_value = AsposeCellsCloud::Object::DataFillValue->new();
	$data_cleansing_data_fill_data_fill_default_value->{default_date} = '2024-01-01' ;
	$data_cleansing_data_fill_data_fill_default_value->{default_number} = 0 ;
	$data_cleansing_data_fill_data_fill_default_value->{default_boolean} = 'false' ;
	my $data_cleansing_data_fill = AsposeCellsCloud::Object::DataFill->new();
	$data_cleansing_data_fill->{data_fill_default_value} = $data_cleansing_data_fill_data_fill_default_value ;
	my $data_cleansing = AsposeCellsCloud::Object::DataCleansing->new();
	$data_cleansing->{need_fill_data} = 'true' ;
	$data_cleansing->{data_fill} = $data_cleansing_data_fill ;

	my $request = AsposeCellsCloud::Request::PostWorkbookDataCleansingRequest->new();
	$request->{name} = $remoteName;
	$request->{data_cleansing} = $data_cleansing;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_data_cleansing(request=> $request);

view raw Example_PostWorkbookDataCleansing.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'BookCsvDuplicateData.csv';
	my $remoteName = 'BookCsvDuplicateData.csv';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $deduplication_region = AsposeCellsCloud::Object::DeduplicationRegion->new();


	my $request = AsposeCellsCloud::Request::PostWorkbookDataDeduplicationRequest->new();
	$request->{name} = $remoteName;
	$request->{deduplication_region} = $deduplication_region;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_data_deduplication(request=> $request);

view raw Example_PostWorkbookDataDeduplication.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'BookCsvDuplicateData.csv';
	my $remoteName = 'BookCsvDuplicateData.csv';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $data_fill_data_fill_default_value = AsposeCellsCloud::Object::DataFillValue->new();
	$data_fill_data_fill_default_value->{default_date} = '2024-01-01' ;
	$data_fill_data_fill_default_value->{default_number} = 0 ;
	$data_fill_data_fill_default_value->{default_boolean} = 'false' ;
	my $data_fill = AsposeCellsCloud::Object::DataFill->new();
	$data_fill->{data_fill_default_value} = $data_fill_data_fill_default_value ;

	my $request = AsposeCellsCloud::Request::PostWorkbookDataFillRequest->new();
	$request->{name} = $remoteName;
	$request->{data_fill} = $data_fill;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_data_fill(request=> $request);

view raw Example_PostWorkbookDataFill.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Template.xlsx';
	my $remoteName = 'Template.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorkbookExportXMLRequest->new();
	$request->{name} = $remoteName;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_export_xml(request=> $request);

view raw Example_PostWorkbookExportXML.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $reportDataXML = 'ReportData.xml';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $reportDataXML => $reportDataXML } ,'path'=>$remoteFolder . '/ReportData.xml' );


	my $request = AsposeCellsCloud::Request::PostWorkbookGetSmartMarkerResultRequest->new();
	$request->{name} = $remoteName;
	$request->{xml_file} = $remoteFolder . '/ReportData.xml';
	$request->{folder} = $remoteFolder;
	$request->{out_path} = 'OutResult/SmartMarkerResult.xlsx';
	$request->{storage_name} = '';
	$request->{out_storage_name} = '';
	$instance->post_workbook_get_smart_marker_result(request=> $request);

view raw Example_PostWorkbookGetSmartMarkerResult.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Template.xlsx';
	my $dataXML = 'data.xml';
	my $remoteName = 'Template.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $dataXML => $dataXML } ,'path'=>$remoteFolder . '/data.xml' );

	my $import_xml_request_xml_file_source = AsposeCellsCloud::Object::FileSource->new();
	$import_xml_request_xml_file_source->{file_source_type} = 'CloudFileSystem' ;
	$import_xml_request_xml_file_source->{file_path} = $remoteFolder . '/data.xml' ;
	my $import_xml_request_import_position = AsposeCellsCloud::Object::ImportPosition->new();
	$import_xml_request_import_position->{sheet_name} = 'Sheet1' ;
	$import_xml_request_import_position->{row_index} = 3 ;
	$import_xml_request_import_position->{column_index} = 4 ;
	my $import_xml_request = AsposeCellsCloud::Object::ImportXMLRequest->new();
	$import_xml_request->{xml_file_source} = $import_xml_request_xml_file_source ;
	$import_xml_request->{import_position} = $import_xml_request_import_position ;

	my $request = AsposeCellsCloud::Request::PostWorkbookImportXMLRequest->new();
	$request->{name} = $remoteName;
	$request->{import_xml_request} = $import_xml_request;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_import_xml(request=> $request);

view raw Example_PostWorkbookImportXML.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $new_name = AsposeCellsCloud::Object::Name->new();
	$new_name->{text} = 'name_1804' ;
	$new_name->{comment} = 'KeepSourceFormatting' ;
	$new_name->{refers_to} = '=Sheet1!$I$4' ;

	my $request = AsposeCellsCloud::Request::PostWorkbookNameRequest->new();
	$request->{name} = $remoteName;
	$request->{name_name} = 'Name_2';
	$request->{new_name} = $new_name;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_name(request=> $request);

view raw Example_PostWorkbookName.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $format = 'csv';
	my $newfilename = 'outResult/PostExcelSaveAs.csv';

	my $save_options = AsposeCellsCloud::Object::PdfSaveOptions->new();
	$save_options->{save_format} = $format ;

	my $request = AsposeCellsCloud::Request::PostWorkbookSaveAsRequest->new();
	$request->{name} = $remoteName;
	$request->{newfilename} = $newfilename;
	$request->{save_options} = $save_options;
	$request->{folder} = $remoteFolder;
	$instance->post_workbook_save_as(request=> $request);

view raw Example_PostWorkbookSaveAs.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $settings = AsposeCellsCloud::Object::WorkbookSettings->new();
	$settings->{auto_compress_pictures} = 'true' ;
	$settings->{hide_pivot_field_list} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorkbookSettingsRequest->new();
	$request->{name} = $remoteName;
	$request->{settings} = $settings;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_settings(request=> $request);

view raw Example_PostWorkbookSettings.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $myDocumentXLSX = 'myDocument.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $myDocumentXLSX => $myDocumentXLSX } ,'path'=>$remoteFolder . '/myDocument.xlsx' );


	my $request = AsposeCellsCloud::Request::PostWorkbooksMergeRequest->new();
	$request->{name} = $remoteName;
	$request->{merge_with} = $remoteFolder . '/myDocument.xlsx';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$request->{merged_storage_name} = '';
	$instance->post_workbooks_merge(request=> $request);

view raw Example_PostWorkbooksMerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorkbookSplitRequest->new();
	$request->{name} = $remoteName;
	$request->{format} = 'png';
	$request->{out_folder} = 'OutResult';
	$request->{from} = 1;
	$request->{to} = 5;
	$request->{horizontal_resolution} = 96;
	$request->{vertical_resolution} = 96;
	$request->{split_name_rule} = 'sheetname';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$request->{out_storage_name} = '';
	$instance->post_workbook_split(request=> $request);

view raw Example_PostWorkbookSplit.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorkbooksTextSearchRequest->new();
	$request->{name} = $remoteName;
	$request->{text} = '1234';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbooks_text_search(request=> $request);

view raw Example_PostWorkbooksTextSearch.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorkbookTextReplaceRequest->new();
	$request->{name} = $remoteName;
	$request->{old_value} = '1234';
	$request->{new_value} = '5678';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_workbook_text_replace(request=> $request);

view raw Example_PostWorkbookTextReplace.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetAutoFilterRefreshRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_auto_filter_refresh(request=> $request);

view raw Example_PostWorksheetAutoFilterRefresh.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetCalculateFormulaRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{formula} = '=NOW()';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_calculate_formula(request=> $request);

view raw Example_PostWorksheetCalculateFormula.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetCellSetValueRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'A1';
	$request->{value} = '1';
	$request->{type} = 'int';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cell_set_value(request=> $request);

view raw Example_PostWorksheetCellSetValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeColumnWidthRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{value} = 10.7;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_column_width(request=> $request);

view raw Example_PostWorksheetCellsRangeColumnWidth.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeMergeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_merge(request=> $request);

view raw Example_PostWorksheetCellsRangeMerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeMoveToRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{dest_row} = 10;
	$request->{dest_column} = 10;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_move_to(request=> $request);

view raw Example_PostWorksheetCellsRangeMoveTo.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range_operateborder_color = AsposeCellsCloud::Object::Color->new();
	$range_operateborder_color->{r} = 48 ;
	$range_operateborder_color->{g} = 48 ;
	$range_operateborder_color->{b} = 48 ;
	my $range_operate_range = AsposeCellsCloud::Object::Range->new();
	$range_operate_range->{column_count} = 1 ;
	$range_operate_range->{column_width} = 10.0 ;
	$range_operate_range->{first_row} = 1 ;
	$range_operate_range->{row_count} = 10 ;
	my $range_operate = AsposeCellsCloud::Object::RangeSetOutlineBorderRequest->new();
	$range_operate->{border_edge} = 'LeftBorder' ;
	$range_operate->{border_style} = 'Dotted' ;
	$range_operate->{border_color} = $range_operateborder_color ;
	$range_operate->{range} = $range_operate_range ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeOutlineBorderRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range_operate} = $range_operate;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_outline_border(request=> $request);

view raw Example_PostWorksheetCellsRangeOutlineBorder.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeRowHeightRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{value} = 10.9;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_row_height(request=> $request);

view raw Example_PostWorksheetCellsRangeRowHeight.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range_operate_source = AsposeCellsCloud::Object::Range->new();
	$range_operate_source->{column_count} = 1 ;
	$range_operate_source->{column_width} = 10.0 ;
	$range_operate_source->{first_row} = 1 ;
	$range_operate_source->{row_count} = 10 ;
	my $range_operate_target = AsposeCellsCloud::Object::Range->new();
	$range_operate_target->{column_count} = 1 ;
	$range_operate_target->{column_width} = 10.0 ;
	$range_operate_target->{first_row} = 10 ;
	$range_operate_target->{row_count} = 10 ;
	my $range_operate = AsposeCellsCloud::Object::RangeCopyRequest->new();
	$range_operate->{operate} = 'copydata' ;
	$range_operate->{source} = $range_operate_source ;
	$range_operate->{target} = $range_operate_target ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangesCopyRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range_operate} = $range_operate;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_ranges_copy(request=> $request);

view raw Example_PostWorksheetCellsRangesCopy.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Group.xlsx';
	my $remoteName = 'Group.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range_sort_request_data_sorter = AsposeCellsCloud::Object::DataSorter->new();
	$range_sort_request_data_sorter->{case_sensitive} = 'true' ;
	my $range_sort_request_cell_area = AsposeCellsCloud::Object::Range->new();
	$range_sort_request_cell_area->{column_count} = 3 ;
	$range_sort_request_cell_area->{first_column} = 0 ;
	$range_sort_request_cell_area->{first_row} = 0 ;
	$range_sort_request_cell_area->{row_count} = 15 ;
	my $range_sort_request = AsposeCellsCloud::Object::RangeSortRequest->new();
	$range_sort_request->{data_sorter} = $range_sort_request_data_sorter ;
	$range_sort_request->{cell_area} = $range_sort_request_cell_area ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeSortRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'book1';
	$request->{range_sort_request} = $range_sort_request;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_sort(request=> $request);

view raw Example_PostWorksheetCellsRangeSort.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range_operate_style_font = AsposeCellsCloud::Object::Font->new();
	$range_operate_style_font->{size} = 16 ;
	my $range_operate_style = AsposeCellsCloud::Object::Style->new();
	$range_operate_style->{font} = $range_operate_style_font ;
	my $range_operate_range = AsposeCellsCloud::Object::Range->new();
	$range_operate_range->{column_count} = 1 ;
	$range_operate_range->{column_width} = 10.0 ;
	$range_operate_range->{first_row} = 1 ;
	$range_operate_range->{row_count} = 10 ;
	my $range_operate = AsposeCellsCloud::Object::RangeSetStyleRequest->new();
	$range_operate->{style} = $range_operate_style ;
	$range_operate->{range} = $range_operate_range ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeStyleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range_operate} = $range_operate;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_style(request=> $request);

view raw Example_PostWorksheetCellsRangeStyle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeUnMergeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_un_merge(request=> $request);

view raw Example_PostWorksheetCellsRangeUnMerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $range = AsposeCellsCloud::Object::Range->new();
	$range->{column_count} = 1 ;
	$range->{column_width} = 10.0 ;
	$range->{first_row} = 1 ;
	$range->{row_count} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCellsRangeValueRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{range} = $range;
	$request->{value} = '100';
	$request->{is_converted} = 'true';
	$request->{set_style} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_cells_range_value(request=> $request);

view raw Example_PostWorksheetCellsRangeValue.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $chart = AsposeCellsCloud::Object::Chart->new();
	$chart->{show_legend} = 'true' ;
	$chart->{show_data_table} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetChartRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{chart} = $chart;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_chart(request=> $request);

view raw Example_PostWorksheetChart.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $legend = AsposeCellsCloud::Object::Legend->new();
	$legend->{position} = 'Top' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetChartLegendRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{legend} = $legend;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_chart_legend(request=> $request);

view raw Example_PostWorksheetChartLegend.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $title = AsposeCellsCloud::Object::Title->new();
	$title->{is_visible} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetChartTitleRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{chart_index} = 0;
	$request->{title} = $title;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_chart_title(request=> $request);

view raw Example_PostWorksheetChartTitle.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $comment = AsposeCellsCloud::Object::Comment->new();
	$comment->{author} = 'aspose cells developer' ;
	$comment->{note} = 'aspose cells cloud api update comment.' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetCommentRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_name} = 'B3';
	$request->{comment} = $comment;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_comment(request=> $request);

view raw Example_PostWorksheetComment.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @list_shape = [];push (@list_shape ,0 );
	push (@list_shape ,1 );

	my $request = AsposeCellsCloud::Request::PostWorksheetGroupShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{list_shape} = []; push ( @{$request->{list_shape}}, 0 );
	push ( @{$request->{list_shape}}, 1 );;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_group_shape(request=> $request);

view raw Example_PostWorksheetGroupShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $hyperlink = AsposeCellsCloud::Object::Hyperlink->new();
	$hyperlink->{address} = 'https://products.aspose.cloud/cells/' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetHyperlinkRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{hyperlink_index} = 0;
	$request->{hyperlink} = $hyperlink;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_hyperlink(request=> $request);

view raw Example_PostWorksheetHyperlink.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $list_column = AsposeCellsCloud::Object::ListColumn->new();
	$list_column->{name} = 'test cloumn' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetListColumnRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{column_index} = 0;
	$request->{list_column} = $list_column;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_column(request=> $request);

view raw Example_PostWorksheetListColumn.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $table_total_requeststable_total_request0 = AsposeCellsCloud::Object::TableTotalRequest->new();
	$table_total_requeststable_total_request0->{list_column_index} = 1 ;
	$table_total_requeststable_total_request0->{totals_calculation} = 'Average' ;
	my @table_total_requests = [];push (@table_total_requests ,$table_total_requeststable_total_request0 );

	my $request = AsposeCellsCloud::Request::PostWorksheetListColumnsTotalRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{table_total_requests} = []; push ( @{$request->{table_total_requests}}, $table_total_requeststable_total_request0 );;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_columns_total(request=> $request);

view raw Example_PostWorksheetListColumnsTotal.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $list_object = AsposeCellsCloud::Object::ListObject->new();
	$list_object->{show_header_row} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{list_object} = $list_object;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object(request=> $request);

view raw Example_PostWorksheetListObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectConvertToRangeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object_convert_to_range(request=> $request);

view raw Example_PostWorksheetListObjectConvertToRange.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestTables.xlsx';
	my $remoteName = 'TestTables.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectInsertSlicerRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{list_object_index} = 0;
	$request->{column_index} = 2;
	$request->{dest_cell_name} = 'j9';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object_insert_slicer(request=> $request);

view raw Example_PostWorksheetListObjectInsertSlicer.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestTables.xlsx';
	my $remoteName = 'TestTables.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectRemoveDuplicatesRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet2';
	$request->{list_object_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object_remove_duplicates(request=> $request);

view raw Example_PostWorksheetListObjectRemoveDuplicates.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $data_sorter = AsposeCellsCloud::Object::DataSorter->new();
	$data_sorter->{case_sensitive} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectSortTableRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{data_sorter} = $data_sorter;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object_sort_table(request=> $request);

view raw Example_PostWorksheetListObjectSortTable.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @create_pivot_table_request_pivot_field_columns = [];push (@create_pivot_table_request_pivot_field_columns ,2 );
	my @create_pivot_table_request_pivot_field_data = [];push (@create_pivot_table_request_pivot_field_data ,1 );
	my @create_pivot_table_request_pivot_field_rows = [];push (@create_pivot_table_request_pivot_field_rows ,0 );
	my $create_pivot_table_request = AsposeCellsCloud::Object::CreatePivotTableRequest->new();
	$create_pivot_table_request->{dest_cell_name} = 'C1' ;
	$create_pivot_table_request->{name} = 'testp' ;
	$create_pivot_table_request->{source_data} = '=Sheet2!A1:E8' ;
	$create_pivot_table_request->{use_same_source} = 'true' ;
	$create_pivot_table_request->{pivot_field_columns} = []; push ( @{$create_pivot_table_request->{pivot_field_columns}}, 2 ); ;
	$create_pivot_table_request->{pivot_field_data} = []; push ( @{$create_pivot_table_request->{pivot_field_data}}, 1 ); ;
	$create_pivot_table_request->{pivot_field_rows} = []; push ( @{$create_pivot_table_request->{pivot_field_rows}}, 0 ); ;

	my $request = AsposeCellsCloud::Request::PostWorksheetListObjectSummarizeWithPivotTableRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet7';
	$request->{list_object_index} = 0;
	$request->{destsheet_name} = 'Sheet2';
	$request->{create_pivot_table_request} = $create_pivot_table_request;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_list_object_summarize_with_pivot_table(request=> $request);

view raw Example_PostWorksheetListObjectSummarizeWithPivotTable.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetMatchBlanksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{field_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_match_blanks(request=> $request);

view raw Example_PostWorksheetMatchBlanks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetMatchNonBlanksRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{field_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_match_non_blanks(request=> $request);

view raw Example_PostWorksheetMatchNonBlanks.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetMergeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_row} = 1;
	$request->{start_column} = 1;
	$request->{total_rows} = 4;
	$request->{total_columns} = 4;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_merge(request=> $request);

view raw Example_PostWorksheetMerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $picture = AsposeCellsCloud::Object::Picture->new();
	$picture->{left} = 10 ;
	$picture->{bottom} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetPictureRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet6';
	$request->{picture_index} = 0;
	$request->{picture} = $picture;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_picture(request=> $request);

view raw Example_PostWorksheetPicture.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetPivotTableCalculateRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_pivot_table_calculate(request=> $request);

view raw Example_PostWorksheetPivotTableCalculate.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetPivotTableMoveRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{row} = 1;
	$request->{column} = 1;
	$request->{dest_cell_name} = 'C10';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_pivot_table_move(request=> $request);

view raw Example_PostWorksheetPivotTableMove.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $data_sorter = AsposeCellsCloud::Object::DataSorter->new();
	$data_sorter->{case_sensitive} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetRangeSortRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cell_area} = 'A1:C10';
	$request->{data_sorter} = $data_sorter;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_range_sort(request=> $request);

view raw Example_PostWorksheetRangeSort.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $dto = AsposeCellsCloud::Object::Shape->new();
	$dto->{lower_right_column} = 10 ;

	my $request = AsposeCellsCloud::Request::PostWorksheetShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{dto} = $dto;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_shape(request=> $request);

view raw Example_PostWorksheetShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $sparkline_group = AsposeCellsCloud::Object::SparklineGroup->new();
	$sparkline_group->{display_hidden} = 'true' ;
	$sparkline_group->{plot_right_to_left} = 'true' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetSparklineGroupRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{sparkline_group_index} = 0;
	$request->{sparkline_group} = $sparkline_group;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_sparkline_group(request=> $request);

view raw Example_PostWorksheetSparklineGroup.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetTextReplaceRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{old_value} = '123';
	$request->{new_value} = '456';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_text_replace(request=> $request);

view raw Example_PostWorksheetTextReplace.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetTextSearchRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{text} = '123';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_text_search(request=> $request);

view raw Example_PostWorksheetTextSearch.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetUngroupShapeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{shapeindex} = 0;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_ungroup_shape(request=> $request);

view raw Example_PostWorksheetUngroupShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PostWorksheetUnmergeRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{start_row} = 1;
	$request->{start_column} = 1;
	$request->{total_rows} = 4;
	$request->{total_columns} = 4;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_unmerge(request=> $request);

view raw Example_PostWorksheetUnmerge.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $validation = AsposeCellsCloud::Object::Validation->new();
	$validation->{formula1} = '=A1' ;
	$validation->{type} = 'Custom' ;

	my $request = AsposeCellsCloud::Request::PostWorksheetValidationRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{validation_index} = 0;
	$request->{validation} = $validation;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->post_worksheet_validation(request=> $request);

view raw Example_PostWorksheetValidation.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutActiveWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_active_worksheet(request=> $request);

view raw Example_PutActiveWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutAddNewWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{position} = 0;
	$request->{sheettype} = 'VB';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_add_new_worksheet(request=> $request);

view raw Example_PutAddNewWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutChangeVisibilityWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{is_visible} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_change_visibility_worksheet(request=> $request);

view raw Example_PutChangeVisibilityWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $format = 'csv';

	my $mapFiles = {};

	$mapFiles->{$localName}= "TestData/".$localName ;

	my $request = AsposeCellsCloud::Request::PutConvertWorkbookRequest->new();
	$request->{file} = $mapFiles;
	$request->{format} = $format;
	$instance->put_convert_workbook(request=> $request);

view raw Example_PutConvertWorkbook.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $property = AsposeCellsCloud::Object::CellsDocumentProperty->new();
	$property->{name} = 'Author' ;
	$property->{value} = 'cells developer' ;

	my $request = AsposeCellsCloud::Request::PutDocumentPropertyRequest->new();
	$request->{name} = $remoteName;
	$request->{property} = $property;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_document_property(request=> $request);

view raw Example_PutDocumentProperty.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $password = AsposeCellsCloud::Object::PasswordRequest->new();
	$password->{password} = '123456' ;

	my $request = AsposeCellsCloud::Request::PutDocumentProtectFromChangesRequest->new();
	$request->{name} = $remoteName;
	$request->{password} = $password;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_document_protect_from_changes(request=> $request);

view raw Example_PutDocumentProtectFromChanges.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutHorizontalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cellname} = 'A1';
	$request->{row} = 1;
	$request->{column} = 1;
	$request->{start_column} = 1;
	$request->{end_column} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_horizontal_page_break(request=> $request);

view raw Example_PutHorizontalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutInsertNewWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{index} = 1;
	$request->{sheettype} = 'VB';
	$request->{newsheetname} = 'VBASheet';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_insert_new_worksheet(request=> $request);

view raw Example_PutInsertNewWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutInsertWorksheetColumnsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{column_index} = 1;
	$request->{columns} = 10;
	$request->{update_reference} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_insert_worksheet_columns(request=> $request);

view raw Example_PutInsertWorksheetColumns.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutInsertWorksheetRowRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{row_index} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_insert_worksheet_row(request=> $request);

view raw Example_PutInsertWorksheetRow.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutInsertWorksheetRowsRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{startrow} = 1;
	$request->{total_rows} = 10;
	$request->{update_reference} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_insert_worksheet_rows(request=> $request);

view raw Example_PutInsertWorksheetRows.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'TestCase.xlsx';
	my $remoteName = 'TestCase.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my @pivot_table_field_request_data = [];push (@pivot_table_field_request_data ,0 );
	my $pivot_table_field_request = AsposeCellsCloud::Object::PivotTableFieldRequest->new();
	$pivot_table_field_request->{data} = []; push ( @{$pivot_table_field_request->{data}}, 0 ); ;

	my $request = AsposeCellsCloud::Request::PutPivotTableFieldRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet4';
	$request->{pivot_table_index} = 0;
	$request->{pivot_field_type} = 'Row';
	$request->{pivot_table_field_request} = $pivot_table_field_request;
	$request->{need_re_calculate} = 'true';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_pivot_table_field(request=> $request);

view raw Example_PutPivotTableField.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $protect_parameter = AsposeCellsCloud::Object::ProtectSheetParameter->new();
	$protect_parameter->{protection_type} = 'ALL' ;
	$protect_parameter->{password} = '123' ;

	my $request = AsposeCellsCloud::Request::PutProtectWorksheetRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{protect_parameter} = $protect_parameter;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_protect_worksheet(request=> $request);

view raw Example_PutProtectWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );


	my $request = AsposeCellsCloud::Request::PutVerticalPageBreakRequest->new();
	$request->{name} = $remoteName;
	$request->{sheet_name} = 'Sheet1';
	$request->{cellname} = 'A1';
	$request->{column} = 1;
	$request->{row} = 1;
	$request->{start_row} = 1;
	$request->{end_row} = 1;
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_vertical_page_break(request=> $request);

view raw Example_PutVerticalPageBreak.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::CellsApi;

	my $config = AsposeCellsCloud::Configuration->new( client_id => $ENV{'CellsCloudClientId'}, client_secret => $ENV{'CellsCloudClientSecret'});
	my $instance = AsposeCellsCloud::CellsApi->new(AsposeCellsCloud::ApiClient->new( $config));

	my $remoteFolder = 'TestData/In';

	my $localName = 'Book1.xlsx';
	my $waterMarkPNG = 'WaterMark.png';
	my $remoteName = 'Book1.xlsx';

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $localName => $localName } ,'path'=>$remoteFolder . '/' . $remoteName );

	my $upload_file_request = AsposeCellsCloud::Request::UploadFileRequest->new( 'UploadFiles'=>{ $waterMarkPNG => $waterMarkPNG } ,'path'=>$remoteFolder . '/WaterMark.png' );


	my $request = AsposeCellsCloud::Request::PutWorkbookBackgroundRequest->new();
	$request->{name} = $remoteName;
	$request->{pic_path} = $remoteFolder . '/WaterMark.png';
	$request->{folder} = $remoteFolder;
	$request->{storage_name} = '';
	$instance->put_workbook_background(request=> $request);

view raw Example_PutWorkbookBackground.pl hosted with ❤ by GitHub

Set Formula for a Cell in Excel Worksheets Clear Cells Formatting in Excel Worksheet