Beräkna Cells formel

Denna REST API indikerar beräkna cells formula i en Excel fil.

RSET API

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

Begärans parametrar är:

Parameternamn	Typ	Sökväg/Frågesträng/HTTPBody	Beskrivning
namn	sträng	väg
arknamn	sträng	väg
cellnamn	sträng	väg
alternativ		kropp
mapp	sträng	fråga
lagringsnamn	sträng	fråga	lagringsnamn.

DeOpenAPI-specifikation definierar ett allmänt tillgängligt programmeringsgränssnitt och låter dig utföra REST-interaktioner direkt från en webbläsare.

Du kan använda cURL kommandoradsverktyg för att enkelt komma åt Aspose.Cells webbtjänster. Följande exempel visar hur man ringer till Cloud API med 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-familj

Att använda en SDK är det bästa sättet att påskynda utvecklingen. En SDK tar hand om detaljer på låg nivå och låter dig fokusera på dina projektuppgifter. Vänligen kolla inGitHub-förråd för en komplett lista med Aspose.Cells Cloud SDK.

Följande kodexempel visar hur man ringer till Aspose.Cells webbtjänster med olika SDK:er:

	// 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 $assemblyTestXlsx = 'assemblytest.xlsx';
	my $book1Xlsx = 'Book1.xlsx';


	my $format = 'png';
	my $objectType = 'chart';

	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_PostExportChart.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 = 'listobject';

	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_PostExportListObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 = 'png';
	my $objectType = 'oleobject';

	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_PostExportOleObject.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 = 'png';
	my $objectType = 'picture';

	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_PostExportPicture.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 = 'png';
	my $objectType = 'shape';

	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_PostExportShape.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 = 'worksheet';

	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_PostExportWorksheet.pl hosted with ❤ by GitHub

	use lib 'lib';
	use strict;
	use warnings;
	use File::Slurp;
	use MIME::Base64;
	use AsposeCellsCloud::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 $localName = 'Book1.xlsx';
	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 $localName = 'Book1.xlsx';
	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_PutConvertWorkbookToCsv.pl hosted with ❤ by GitHub

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

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

	my $localName = 'Book1.xlsx';
	my $format = 'docx';
	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_PutConvertWorkbookToDocx.pl hosted with ❤ by GitHub

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

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

	my $localName = 'Book1.xlsx';
	my $format = 'html';
	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_PutConvertWorkbookToHtml.pl hosted with ❤ by GitHub

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

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

	my $localName = 'Book1.xlsx';
	my $format = 'pdf';
	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_PutConvertWorkbookToPdf.pl hosted with ❤ by GitHub

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

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

	my $localName = 'Book1.xlsx';
	my $format = 'tiff';
	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_PutConvertWorkbookToTiff.pl hosted with ❤ by GitHub

Ställ in formel för en cell i arbetsbladet Excel Rensa Cells Formatering i Excel Arbetsblad