!Aspose.Words Cloud for C++

This Gist contains C++ code samples for Aspose.Words Cloud API

AcceptAllRevisions.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::AcceptAllRevisionsRequest> acceptRequest(
    new requests::AcceptAllRevisionsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->acceptAllRevisions(acceptRequest);

AcceptAllRevisionsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::AcceptAllRevisionsOnlineRequest> acceptRequest(
    new requests::AcceptAllRevisionsOnlineRequest(
        requestDocument));
wordsApi->acceptAllRevisionsOnline(acceptRequest);

AppendDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::wstring remoteFileName = L"Sample.docx";

auto requestDocumentListDocumentEntries0FileReference = std::make_shared<aspose::words::cloud::models::FileReference>(std::make_shared<std::wstring>(remoteFileName));
auto requestDocumentListDocumentEntries0 = std::make_shared<aspose::words::cloud::models::DocumentEntry>();
requestDocumentListDocumentEntries0->setFileReference(requestDocumentListDocumentEntries0FileReference);
requestDocumentListDocumentEntries0->setImportFormatMode(std::make_shared<std::wstring>(L"KeepSourceFormatting"));
auto requestDocumentListDocumentEntries = std::make_shared<std::vector<std::shared_ptr<aspose::words::cloud::models::DocumentEntry>>>();
requestDocumentListDocumentEntries->push_back(requestDocumentListDocumentEntries0);
auto requestDocumentList = std::make_shared<aspose::words::cloud::models::DocumentEntryList>();
requestDocumentList->setDocumentEntries(requestDocumentListDocumentEntries);
std::shared_ptr<requests::AppendDocumentRequest> appendRequest(
    new requests::AppendDocumentRequest(
        std::make_shared<std::wstring>(remoteFileName), requestDocumentList));
wordsApi->appendDocument(appendRequest);

AppendDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::wstring localFile = L"Sample.docx";

auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(localFile), std::istream::binary));
auto requestDocumentListDocumentEntries0FileReferenceStream = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(getDataDir(localFile)), std::istream::binary));
auto requestDocumentListDocumentEntries0FileReference = std::make_shared<aspose::words::cloud::models::FileReference>(requestDocumentListDocumentEntries0FileReferenceStream);
auto requestDocumentListDocumentEntries0 = std::make_shared<aspose::words::cloud::models::DocumentEntry>();
requestDocumentListDocumentEntries0->setFileReference(requestDocumentListDocumentEntries0FileReference);
requestDocumentListDocumentEntries0->setImportFormatMode(std::make_shared<std::wstring>(L"KeepSourceFormatting"));
auto requestDocumentListDocumentEntries = std::make_shared<std::vector<std::shared_ptr<aspose::words::cloud::models::DocumentEntry>>>();
requestDocumentListDocumentEntries->push_back(requestDocumentListDocumentEntries0);
auto requestDocumentList = std::make_shared<aspose::words::cloud::models::DocumentEntryList>();
requestDocumentList->setDocumentEntries(requestDocumentListDocumentEntries);
std::shared_ptr<requests::AppendDocumentOnlineRequest> appendRequest(
    new requests::AppendDocumentOnlineRequest(
        requestDocument, requestDocumentList));
wordsApi->appendDocumentOnline(appendRequest);

ApplyStyleToDocumentElement.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestStyleApply = std::make_shared<aspose::words::cloud::models::StyleApply>();
requestStyleApply->setStyleName(std::make_shared<std::wstring>(L"Heading 1"));
std::shared_ptr<requests::ApplyStyleToDocumentElementRequest> applyStyleRequest(
    new requests::ApplyStyleToDocumentElementRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/1/paragraphFormat"), requestStyleApply));
wordsApi->applyStyleToDocumentElement(applyStyleRequest);

ApplyStyleToDocumentElementOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestStyleApply = std::make_shared<aspose::words::cloud::models::StyleApply>();
requestStyleApply->setStyleName(std::make_shared<std::wstring>(L"Heading 1"));
std::shared_ptr<requests::ApplyStyleToDocumentElementOnlineRequest> applyStyleRequest(
    new requests::ApplyStyleToDocumentElementOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/1/paragraphFormat"), requestStyleApply));
wordsApi->applyStyleToDocumentElementOnline(applyStyleRequest);

BuildReport.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestReportEngineSettingsReportBuildOptions = std::make_shared<std::vector<std::shared_ptr<aspose::words::cloud::models::ReportBuildOptions>>>();
requestReportEngineSettingsReportBuildOptions->push_back(std::make_shared<aspose::words::cloud::models::ReportBuildOptions>(aspose::words::cloud::models::ReportBuildOptions::ALLOW_MISSING_MEMBERS));
requestReportEngineSettingsReportBuildOptions->push_back(std::make_shared<aspose::words::cloud::models::ReportBuildOptions>(aspose::words::cloud::models::ReportBuildOptions::REMOVE_EMPTY_PARAGRAPHS));
auto requestReportEngineSettings = std::make_shared<aspose::words::cloud::models::ReportEngineSettings>();
requestReportEngineSettings->setDataSourceType(std::make_shared<aspose::words::cloud::models::ReportEngineSettings::DataSourceType>(aspose::words::cloud::models::ReportEngineSettings::DataSourceType::JSON));
requestReportEngineSettings->setReportBuildOptions(requestReportEngineSettingsReportBuildOptions);
std::shared_ptr<requests::BuildReportRequest> buildReportRequest(
    new requests::BuildReportRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"Data.json"), requestReportEngineSettings));
wordsApi->buildReport(buildReportRequest);

BuildReportOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestReportEngineSettings = std::make_shared<aspose::words::cloud::models::ReportEngineSettings>();
requestReportEngineSettings->setDataSourceType(std::make_shared<aspose::words::cloud::models::ReportEngineSettings::DataSourceType>(aspose::words::cloud::models::ReportEngineSettings::DataSourceType::JSON));
requestReportEngineSettings->setDataSourceName(std::make_shared<std::wstring>(L"persons"));
std::shared_ptr<requests::BuildReportOnlineRequest> buildReportRequest(
    new requests::BuildReportOnlineRequest(
        requestTemplate, std::make_shared<std::wstring>(L"Data.json"), requestReportEngineSettings));
wordsApi->buildReportOnline(buildReportRequest);

Classify.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::ClassifyRequest> classifyRequest(
    new requests::ClassifyRequest(
        std::make_shared<std::wstring>(L"Try text classification"), std::make_shared<std::wstring>(L"3")));
wordsApi->classify(classifyRequest);

ClassifyDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::ClassifyDocumentRequest> classifyRequest(
    new requests::ClassifyDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"3")));
wordsApi->classifyDocument(classifyRequest);

ClassifyDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::ClassifyDocumentOnlineRequest> classifyRequest(
    new requests::ClassifyDocumentOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"3")));
wordsApi->classifyDocumentOnline(classifyRequest);

CompareDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCompareData = std::make_shared<aspose::words::cloud::models::CompareData>();
requestCompareData->setAuthor(std::make_shared<std::wstring>(L"author"));
requestCompareData->setComparingWithDocument(std::make_shared<std::wstring>(L"TestCompareDocument2.doc"));
requestCompareData->setDateTime(std::make_shared<std::wstring>(L"2015-10-26T00:00:00.0000000Z"));
std::shared_ptr<requests::CompareDocumentRequest> compareRequest(
    new requests::CompareDocumentRequest(
        std::make_shared<std::wstring>(L"TestCompareDocument1.doc"), requestCompareData, std::make_shared<std::wstring>(L"CompareDocumentOut.doc")));
wordsApi->compareDocument(compareRequest);

CompareDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"compareTestDoc1.doc"), std::istream::binary));
auto requestCompareData = std::make_shared<aspose::words::cloud::models::CompareData>();
requestCompareData->setAuthor(std::make_shared<std::wstring>(L"author"));
requestCompareData->setComparingWithDocument(std::make_shared<std::wstring>(L"TestCompareDocument2.doc"));
requestCompareData->setDateTime(std::make_shared<std::wstring>(L"2015-10-26T00:00:00.0000000Z"));
auto requestComparingDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"compareTestDoc2.doc"), std::istream::binary));
std::shared_ptr<requests::CompareDocumentOnlineRequest> compareRequest(
    new requests::CompareDocumentOnlineRequest(
        requestDocument, requestCompareData, requestComparingDocument, std::make_shared<std::wstring>(L"CompareDocumentOut.doc")));
wordsApi->compareDocumentOnline(compareRequest);

CompressDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCompressOptions = std::make_shared<aspose::words::cloud::models::CompressOptions>();

std::shared_ptr<requests::CompressDocumentRequest> compressDocument(
    new requests::CompressDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestCompressOptions));
wordsApi->compressDocument(compressDocument);

CompressDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"TestCompress.docx"), std::istream::binary));
auto requestCompressOptions = std::make_shared<aspose::words::cloud::models::CompressOptions>();

std::shared_ptr<requests::CompressDocumentOnlineRequest> compressDocumentOnline(
    new requests::CompressDocumentOnlineRequest(
        requestDocument, requestCompressOptions));
wordsApi->compressDocumentOnline(compressDocumentOnline);

ConvertDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::ConvertDocumentRequest> convertRequest(
    new requests::ConvertDocumentRequest(
        requestDocument, std::make_shared<std::wstring>(L"pdf")));
wordsApi->convertDocument(convertRequest);

ConvertDocument_1.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::ConvertDocumentRequest> convertRequest(
    new requests::ConvertDocumentRequest(
        requestDocument, std::make_shared<std::wstring>(L"pdf")));
wordsApi->convertDocument(convertRequest);

ConvertDocument_2.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::ConvertDocumentRequest> convertRequest(
    new requests::ConvertDocumentRequest(
        requestDocument, std::make_shared<std::wstring>(L"pdf")));
wordsApi->convertDocument(convertRequest);

CopyFile.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::CopyFileRequest> copyRequest(
    new requests::CopyFileRequest(
        std::make_shared<std::wstring>(L"Copy.docx"), std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->copyFile(copyRequest);

CopyFolder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::wstring folderToCopy = L"/TestCopyFolder";

std::shared_ptr<requests::CopyFolderRequest> copyRequest(
    new requests::CopyFolderRequest(
        std::make_shared<std::wstring>(folderToCopy + L"Dest"), std::make_shared<std::wstring>(folderToCopy + L"Src")));
wordsApi->copyFolder(copyRequest);

CopyStyle.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestStyleCopy = std::make_shared<aspose::words::cloud::models::StyleCopy>();
requestStyleCopy->setStyleName(std::make_shared<std::wstring>(L"Heading 1"));
std::shared_ptr<requests::CopyStyleRequest> copyRequest(
    new requests::CopyStyleRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestStyleCopy));
wordsApi->copyStyle(copyRequest);

CopyStyleOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestStyleCopy = std::make_shared<aspose::words::cloud::models::StyleCopy>();
requestStyleCopy->setStyleName(std::make_shared<std::wstring>(L"Heading 1"));
std::shared_ptr<requests::CopyStyleOnlineRequest> copyRequest(
    new requests::CopyStyleOnlineRequest(
        requestDocument, requestStyleCopy));
wordsApi->copyStyleOnline(copyRequest);

CopyStylesFromTemplate.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::CopyStylesFromTemplateRequest> copyRequest(
    new requests::CopyStylesFromTemplateRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"StyleTemplate.docx")));
wordsApi->copyStylesFromTemplate(copyRequest);

CreateDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::CreateDocumentRequest> createRequest(
    new requests::CreateDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->createDocument(createRequest);

CreateFolder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::CreateFolderRequest> createRequest(
    new requests::CreateFolderRequest(
        std::make_shared<std::wstring>(L"/TestCreateFolder")));
wordsApi->createFolder(createRequest);

CreateOrUpdateDocumentProperty.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestProperty = std::make_shared<aspose::words::cloud::models::DocumentPropertyCreateOrUpdate>();
requestProperty->setValue(std::make_shared<std::wstring>(L"John Doe"));
std::shared_ptr<requests::CreateOrUpdateDocumentPropertyRequest> createRequest(
    new requests::CreateOrUpdateDocumentPropertyRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"AsposeAuthor"), requestProperty));
wordsApi->createOrUpdateDocumentProperty(createRequest);

CreateOrUpdateDocumentPropertyOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestProperty = std::make_shared<aspose::words::cloud::models::DocumentPropertyCreateOrUpdate>();
requestProperty->setValue(std::make_shared<std::wstring>(L"John Doe"));
std::shared_ptr<requests::CreateOrUpdateDocumentPropertyOnlineRequest> createRequest(
    new requests::CreateOrUpdateDocumentPropertyOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"AsposeAuthor"), requestProperty));
wordsApi->createOrUpdateDocumentPropertyOnline(createRequest);

DeleteAllParagraphTabStops.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteAllParagraphTabStopsRequest> deleteRequest(
    new requests::DeleteAllParagraphTabStopsRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteAllParagraphTabStops(deleteRequest);

DeleteAllParagraphTabStopsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteAllParagraphTabStopsOnlineRequest> deleteRequest(
    new requests::DeleteAllParagraphTabStopsOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteAllParagraphTabStopsOnline(deleteRequest);

DeleteBookmark.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteBookmarkRequest> deleteRequest(
    new requests::DeleteBookmarkRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"aspose")));
wordsApi->deleteBookmark(deleteRequest);

DeleteBookmarkOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteBookmarkOnlineRequest> deleteRequest(
    new requests::DeleteBookmarkOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"aspose")));
wordsApi->deleteBookmarkOnline(deleteRequest);

DeleteBookmarks.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteBookmarksRequest> deleteRequest(
    new requests::DeleteBookmarksRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteBookmarks(deleteRequest);

DeleteBookmarksOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteBookmarksOnlineRequest> deleteRequest(
    new requests::DeleteBookmarksOnlineRequest(
        requestDocument));
wordsApi->deleteBookmarksOnline(deleteRequest);

DeleteBorder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteBorderRequest> deleteRequest(
    new requests::DeleteBorderRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"left"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->deleteBorder(deleteRequest);

DeleteBorderOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteBorderOnlineRequest> deleteRequest(
    new requests::DeleteBorderOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"left"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->deleteBorderOnline(deleteRequest);

DeleteBorders.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteBordersRequest> deleteRequest(
    new requests::DeleteBordersRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->deleteBorders(deleteRequest);

DeleteBordersOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteBordersOnlineRequest> deleteRequest(
    new requests::DeleteBordersOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->deleteBordersOnline(deleteRequest);

DeleteComment.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteCommentRequest> deleteRequest(
    new requests::DeleteCommentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteComment(deleteRequest);

DeleteCommentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteCommentOnlineRequest> deleteRequest(
    new requests::DeleteCommentOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteCommentOnline(deleteRequest);

DeleteComments.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteCommentsRequest> deleteRequest(
    new requests::DeleteCommentsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteComments(deleteRequest);

DeleteCommentsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteCommentsOnlineRequest> deleteRequest(
    new requests::DeleteCommentsOnlineRequest(
        requestDocument));
wordsApi->deleteCommentsOnline(deleteRequest);

DeleteCustomXmlPart.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteCustomXmlPartRequest> deleteRequest(
    new requests::DeleteCustomXmlPartRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteCustomXmlPart(deleteRequest);

DeleteCustomXmlPartOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteCustomXmlPartOnlineRequest> deleteRequest(
    new requests::DeleteCustomXmlPartOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteCustomXmlPartOnline(deleteRequest);

DeleteCustomXmlParts.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteCustomXmlPartsRequest> deleteRequest(
    new requests::DeleteCustomXmlPartsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteCustomXmlParts(deleteRequest);

DeleteCustomXmlPartsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteCustomXmlPartsOnlineRequest> deleteRequest(
    new requests::DeleteCustomXmlPartsOnlineRequest(
        requestDocument));
wordsApi->deleteCustomXmlPartsOnline(deleteRequest);

DeleteDocumentProperty.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteDocumentPropertyRequest> deleteRequest(
    new requests::DeleteDocumentPropertyRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"testProp")));
wordsApi->deleteDocumentProperty(deleteRequest);

DeleteDocumentPropertyOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteDocumentPropertyOnlineRequest> deleteRequest(
    new requests::DeleteDocumentPropertyOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"testProp")));
wordsApi->deleteDocumentPropertyOnline(deleteRequest);

DeleteDrawingObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteDrawingObjectRequest> deleteRequest(
    new requests::DeleteDrawingObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteDrawingObject(deleteRequest);

DeleteDrawingObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteDrawingObjectOnlineRequest> deleteRequest(
    new requests::DeleteDrawingObjectOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteDrawingObjectOnline(deleteRequest);

DeleteField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFieldRequest> deleteRequest(
    new requests::DeleteFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteField(deleteRequest);

DeleteFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteFieldOnlineRequest> deleteRequest(
    new requests::DeleteFieldOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->deleteFieldOnline(deleteRequest);

DeleteFields.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFieldsRequest> deleteRequest(
    new requests::DeleteFieldsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteFields(deleteRequest);

DeleteFieldsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteFieldsOnlineRequest> deleteRequest(
    new requests::DeleteFieldsOnlineRequest(
        requestDocument));
wordsApi->deleteFieldsOnline(deleteRequest);

DeleteFile.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFileRequest> deleteRequest(
    new requests::DeleteFileRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteFile(deleteRequest);

DeleteFolder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFolderRequest> deleteRequest(
    new requests::DeleteFolderRequest(
        std::make_shared<std::wstring>(L"")));
wordsApi->deleteFolder(deleteRequest);

DeleteFootnote.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFootnoteRequest> deleteRequest(
    new requests::DeleteFootnoteRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteFootnote(deleteRequest);

DeleteFootnoteOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::DeleteFootnoteOnlineRequest> deleteRequest(
    new requests::DeleteFootnoteOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteFootnoteOnline(deleteRequest);

DeleteFormField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteFormFieldRequest> deleteRequest(
    new requests::DeleteFormFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteFormField(deleteRequest);

DeleteFormFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteFormFieldOnlineRequest> deleteRequest(
    new requests::DeleteFormFieldOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->deleteFormFieldOnline(deleteRequest);

DeleteHeaderFooter.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteHeaderFooterRequest> deleteRequest(
    new requests::DeleteHeaderFooterRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L""), std::make_shared<int32_t>(0)));
wordsApi->deleteHeaderFooter(deleteRequest);

DeleteHeaderFooterOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::DeleteHeaderFooterOnlineRequest> deleteRequest(
    new requests::DeleteHeaderFooterOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L""), std::make_shared<int32_t>(0)));
wordsApi->deleteHeaderFooterOnline(deleteRequest);

DeleteHeadersFooters.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteHeadersFootersRequest> deleteRequest(
    new requests::DeleteHeadersFootersRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"")));
wordsApi->deleteHeadersFooters(deleteRequest);

DeleteHeadersFootersOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::DeleteHeadersFootersOnlineRequest> deleteRequest(
    new requests::DeleteHeadersFootersOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"")));
wordsApi->deleteHeadersFootersOnline(deleteRequest);

DeleteMacros.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteMacrosRequest> deleteRequest(
    new requests::DeleteMacrosRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteMacros(deleteRequest);

DeleteMacrosOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteMacrosOnlineRequest> deleteRequest(
    new requests::DeleteMacrosOnlineRequest(
        requestDocument));
wordsApi->deleteMacrosOnline(deleteRequest);

DeleteOfficeMathObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteOfficeMathObjectRequest> deleteRequest(
    new requests::DeleteOfficeMathObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteOfficeMathObject(deleteRequest);

DeleteOfficeMathObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteOfficeMathObjectOnlineRequest> deleteRequest(
    new requests::DeleteOfficeMathObjectOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteOfficeMathObjectOnline(deleteRequest);

DeleteParagraph.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteParagraphRequest> deleteRequest(
    new requests::DeleteParagraphRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteParagraph(deleteRequest);

DeleteParagraphListFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteParagraphListFormatRequest> deleteRequest(
    new requests::DeleteParagraphListFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteParagraphListFormat(deleteRequest);

DeleteParagraphListFormatOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::DeleteParagraphListFormatOnlineRequest> deleteRequest(
    new requests::DeleteParagraphListFormatOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteParagraphListFormatOnline(deleteRequest);

DeleteParagraphOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteParagraphOnlineRequest> deleteRequest(
    new requests::DeleteParagraphOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteParagraphOnline(deleteRequest);

DeleteParagraphTabStop.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteParagraphTabStopRequest> deleteRequest(
    new requests::DeleteParagraphTabStopRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<double>(72.0), std::make_shared<int32_t>(0)));
wordsApi->deleteParagraphTabStop(deleteRequest);

DeleteParagraphTabStopOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteParagraphTabStopOnlineRequest> deleteRequest(
    new requests::DeleteParagraphTabStopOnlineRequest(
        requestDocument, std::make_shared<double>(72.0), std::make_shared<int32_t>(0)));
wordsApi->deleteParagraphTabStopOnline(deleteRequest);

DeleteRun.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteRunRequest> deleteRequest(
    new requests::DeleteRunRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/1"), std::make_shared<int32_t>(0)));
wordsApi->deleteRun(deleteRequest);

DeleteRunOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::DeleteRunOnlineRequest> deleteRequest(
    new requests::DeleteRunOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/1"), std::make_shared<int32_t>(0)));
wordsApi->deleteRunOnline(deleteRequest);

DeleteSection.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteSectionRequest> deleteRequest(
    new requests::DeleteSectionRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->deleteSection(deleteRequest);

DeleteSectionOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteSectionOnlineRequest> deleteRequest(
    new requests::DeleteSectionOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->deleteSectionOnline(deleteRequest);

DeleteStructuredDocumentTag.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteStructuredDocumentTagRequest> deleteRequest(
    new requests::DeleteStructuredDocumentTagRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->deleteStructuredDocumentTag(deleteRequest);

DeleteStructuredDocumentTagOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteStructuredDocumentTagOnlineRequest> deleteRequest(
    new requests::DeleteStructuredDocumentTagOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->deleteStructuredDocumentTagOnline(deleteRequest);

DeleteTable.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteTableRequest> deleteRequest(
    new requests::DeleteTableRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(1)));
wordsApi->deleteTable(deleteRequest);

DeleteTableCell.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteTableCellRequest> deleteRequest(
    new requests::DeleteTableCellRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->deleteTableCell(deleteRequest);

DeleteTableCellOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteTableCellOnlineRequest> deleteRequest(
    new requests::DeleteTableCellOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->deleteTableCellOnline(deleteRequest);

DeleteTableOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteTableOnlineRequest> deleteRequest(
    new requests::DeleteTableOnlineRequest(
        requestDocument, std::make_shared<int32_t>(1)));
wordsApi->deleteTableOnline(deleteRequest);

DeleteTableRow.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteTableRowRequest> deleteRequest(
    new requests::DeleteTableRowRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"tables/1"), std::make_shared<int32_t>(0)));
wordsApi->deleteTableRow(deleteRequest);

DeleteTableRowOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteTableRowOnlineRequest> deleteRequest(
    new requests::DeleteTableRowOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"tables/1"), std::make_shared<int32_t>(0)));
wordsApi->deleteTableRowOnline(deleteRequest);

DeleteWatermark.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DeleteWatermarkRequest> deleteRequest(
    new requests::DeleteWatermarkRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->deleteWatermark(deleteRequest);

DeleteWatermarkOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::DeleteWatermarkOnlineRequest> deleteRequest(
    new requests::DeleteWatermarkOnlineRequest(
        requestDocument));
wordsApi->deleteWatermarkOnline(deleteRequest);

DownloadFile.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::DownloadFileRequest> downloadRequest(
    new requests::DownloadFileRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->downloadFile(downloadRequest);

ExecuteMailMerge.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestOptionsCurrentUser = std::make_shared<aspose::words::cloud::models::UserInformation>();
requestOptionsCurrentUser->setName(std::make_shared<std::wstring>(L"SdkTestUser"));
auto requestOptions = std::make_shared<aspose::words::cloud::models::FieldOptions>();
requestOptions->setCurrentUser(requestOptionsCurrentUser);
std::shared_ptr<requests::ExecuteMailMergeRequest> mailMergeRequest(
    new requests::ExecuteMailMergeRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(getFileTextUtf16(localTestDataFolder + L"/" + L"TestMailMergeData.xml")), requestOptions));
wordsApi->executeMailMerge(mailMergeRequest);

ExecuteMailMergeOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestData = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(getFileTextUtf16(localTestDataFolder + L"/" + L"TestMailMergeData.xml")), std::istream::binary));
auto requestOptionsCurrentUser = std::make_shared<aspose::words::cloud::models::UserInformation>();
requestOptionsCurrentUser->setName(std::make_shared<std::wstring>(L"SdkTestUser"));
auto requestOptions = std::make_shared<aspose::words::cloud::models::FieldOptions>();
requestOptions->setCurrentUser(requestOptionsCurrentUser);
std::shared_ptr<requests::ExecuteMailMergeOnlineRequest> mailMergeRequest(
    new requests::ExecuteMailMergeOnlineRequest(
        requestTemplate, requestData, requestOptions));
wordsApi->executeMailMergeOnline(mailMergeRequest);

ExecuteMailMergeOnline_1.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"TestMailMergeWithImages.doc"), std::istream::binary));
auto requestData = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"MailMergeData.json"), std::istream::binary));
std::shared_ptr<requests::ExecuteMailMergeOnlineRequest> mailMergeRequest(
    new requests::ExecuteMailMergeOnlineRequest(
        requestTemplate, requestData, std::make_shared<std::wstring>(L"Out_TestMailMergeWithImages.doc")));
wordsApi->executeMailMergeOnline(mailMergeRequest);

ExecuteMailMergeOnline_2.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"template.doc"), std::istream::binary));
auto requestData = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"TestPostDocumentExecuteMailMerge.txt"), std::istream::binary));
std::shared_ptr<requests::ExecuteMailMergeOnlineRequest> mailMergeRequest(
    new requests::ExecuteMailMergeOnlineRequest(
        requestTemplate, requestData, std::make_shared<std::wstring>(L"Out_PostDocumentExecuteMailMergeWithHTMLData.docx")));
wordsApi->executeMailMergeOnline(mailMergeRequest);

ExecuteMailMergeOnline_3.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"SampleMailMergeTemplate.docx"), std::istream::binary));
auto requestData = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"SampleMailMergeTemplateData.xml"), std::istream::binary));
std::shared_ptr<requests::ExecuteMailMergeOnlineRequest> mailMergeRequest(
    new requests::ExecuteMailMergeOnlineRequest(
        requestTemplate, requestData, std::make_shared<std::wstring>(L"Out_SampleMailMergeTemplate.docx")));
wordsApi->executeMailMergeOnline(mailMergeRequest);

GetAvailableFonts.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetAvailableFontsRequest> request(
    new requests::GetAvailableFontsRequest());
wordsApi->getAvailableFonts(request);

GetBookmarkByName.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetBookmarkByNameRequest> request(
    new requests::GetBookmarkByNameRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"aspose")));
wordsApi->getBookmarkByName(request);

GetBookmarkByNameOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetBookmarkByNameOnlineRequest> request(
    new requests::GetBookmarkByNameOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"aspose")));
wordsApi->getBookmarkByNameOnline(request);

GetBookmarks.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetBookmarksRequest> request(
    new requests::GetBookmarksRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getBookmarks(request);

GetBookmarksOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetBookmarksOnlineRequest> request(
    new requests::GetBookmarksOnlineRequest(
        requestDocument));
wordsApi->getBookmarksOnline(request);

GetBorder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetBorderRequest> request(
    new requests::GetBorderRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"left"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->getBorder(request);

GetBorderOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetBorderOnlineRequest> request(
    new requests::GetBorderOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"left"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->getBorderOnline(request);

GetBorders.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetBordersRequest> request(
    new requests::GetBordersRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->getBorders(request);

GetBordersOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetBordersOnlineRequest> request(
    new requests::GetBordersOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->getBordersOnline(request);

GetComment.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetCommentRequest> request(
    new requests::GetCommentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getComment(request);

GetCommentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetCommentOnlineRequest> request(
    new requests::GetCommentOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getCommentOnline(request);

GetComments.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetCommentsRequest> request(
    new requests::GetCommentsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getComments(request);

GetCommentsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetCommentsOnlineRequest> request(
    new requests::GetCommentsOnlineRequest(
        requestDocument));
wordsApi->getCommentsOnline(request);

GetCustomXmlPart.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetCustomXmlPartRequest> request(
    new requests::GetCustomXmlPartRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getCustomXmlPart(request);

GetCustomXmlPartOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetCustomXmlPartOnlineRequest> request(
    new requests::GetCustomXmlPartOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getCustomXmlPartOnline(request);

GetCustomXmlParts.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetCustomXmlPartsRequest> request(
    new requests::GetCustomXmlPartsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getCustomXmlParts(request);

GetCustomXmlPartsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetCustomXmlPartsOnlineRequest> request(
    new requests::GetCustomXmlPartsOnlineRequest(
        requestDocument));
wordsApi->getCustomXmlPartsOnline(request);

GetDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentRequest> request(
    new requests::GetDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocument(request);

GetDocumentDrawingObjectByIndex.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentDrawingObjectByIndexRequest> request(
    new requests::GetDocumentDrawingObjectByIndexRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getDocumentDrawingObjectByIndex(request);

GetDocumentDrawingObjectByIndexOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentDrawingObjectByIndexOnlineRequest> request(
    new requests::GetDocumentDrawingObjectByIndexOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getDocumentDrawingObjectByIndexOnline(request);

GetDocumentDrawingObjectImageData.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentDrawingObjectImageDataRequest> request(
    new requests::GetDocumentDrawingObjectImageDataRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getDocumentDrawingObjectImageData(request);

GetDocumentDrawingObjectImageDataOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentDrawingObjectImageDataOnlineRequest> request(
    new requests::GetDocumentDrawingObjectImageDataOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getDocumentDrawingObjectImageDataOnline(request);

GetDocumentDrawingObjectOleData.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentDrawingObjectOleDataRequest> request(
    new requests::GetDocumentDrawingObjectOleDataRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getDocumentDrawingObjectOleData(request);

GetDocumentDrawingObjectOleDataOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentDrawingObjectOleDataOnlineRequest> request(
    new requests::GetDocumentDrawingObjectOleDataOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getDocumentDrawingObjectOleDataOnline(request);

GetDocumentDrawingObjects.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentDrawingObjectsRequest> request(
    new requests::GetDocumentDrawingObjectsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentDrawingObjects(request);

GetDocumentDrawingObjectsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentDrawingObjectsOnlineRequest> request(
    new requests::GetDocumentDrawingObjectsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getDocumentDrawingObjectsOnline(request);

GetDocumentFieldNames.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentFieldNamesRequest> request(
    new requests::GetDocumentFieldNamesRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentFieldNames(request);

GetDocumentFieldNamesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTemplate = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentFieldNamesOnlineRequest> request(
    new requests::GetDocumentFieldNamesOnlineRequest(
        requestTemplate, std::make_shared<bool>(true)));
wordsApi->getDocumentFieldNamesOnline(request);

GetDocumentHyperlinkByIndex.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentHyperlinkByIndexRequest> request(
    new requests::GetDocumentHyperlinkByIndexRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getDocumentHyperlinkByIndex(request);

GetDocumentHyperlinkByIndexOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentHyperlinkByIndexOnlineRequest> request(
    new requests::GetDocumentHyperlinkByIndexOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getDocumentHyperlinkByIndexOnline(request);

GetDocumentHyperlinks.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentHyperlinksRequest> request(
    new requests::GetDocumentHyperlinksRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentHyperlinks(request);

GetDocumentHyperlinksOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentHyperlinksOnlineRequest> request(
    new requests::GetDocumentHyperlinksOnlineRequest(
        requestDocument));
wordsApi->getDocumentHyperlinksOnline(request);

GetDocumentProperties.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentPropertiesRequest> request(
    new requests::GetDocumentPropertiesRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentProperties(request);

GetDocumentPropertiesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentPropertiesOnlineRequest> request(
    new requests::GetDocumentPropertiesOnlineRequest(
        requestDocument));
wordsApi->getDocumentPropertiesOnline(request);

GetDocumentProperty.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentPropertyRequest> request(
    new requests::GetDocumentPropertyRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"Author")));
wordsApi->getDocumentProperty(request);

GetDocumentPropertyOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentPropertyOnlineRequest> request(
    new requests::GetDocumentPropertyOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"Author")));
wordsApi->getDocumentPropertyOnline(request);

GetDocumentProtection.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentProtectionRequest> request(
    new requests::GetDocumentProtectionRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentProtection(request);

GetDocumentProtectionOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentProtectionOnlineRequest> request(
    new requests::GetDocumentProtectionOnlineRequest(
        requestDocument));
wordsApi->getDocumentProtectionOnline(request);

GetDocumentStatistics.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentStatisticsRequest> request(
    new requests::GetDocumentStatisticsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getDocumentStatistics(request);

GetDocumentStatisticsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetDocumentStatisticsOnlineRequest> request(
    new requests::GetDocumentStatisticsOnlineRequest(
        requestDocument));
wordsApi->getDocumentStatisticsOnline(request);

GetDocumentWithFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetDocumentWithFormatRequest> request(
    new requests::GetDocumentWithFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"text"), std::make_shared<std::wstring>(L"DocumentWithFormat.text")));
wordsApi->getDocumentWithFormat(request);

GetField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFieldRequest> request(
    new requests::GetFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getField(request);

GetFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetFieldOnlineRequest> request(
    new requests::GetFieldOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->getFieldOnline(request);

GetFields.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFieldsRequest> request(
    new requests::GetFieldsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getFields(request);

GetFieldsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetFieldsOnlineRequest> request(
    new requests::GetFieldsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getFieldsOnline(request);

GetFilesList.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFilesListRequest> request(
    new requests::GetFilesListRequest(
        std::make_shared<std::wstring>(L"")));
wordsApi->getFilesList(request);

GetFootnote.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFootnoteRequest> request(
    new requests::GetFootnoteRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getFootnote(request);

GetFootnoteOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetFootnoteOnlineRequest> request(
    new requests::GetFootnoteOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getFootnoteOnline(request);

GetFootnotes.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFootnotesRequest> request(
    new requests::GetFootnotesRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getFootnotes(request);

GetFootnotesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetFootnotesOnlineRequest> request(
    new requests::GetFootnotesOnlineRequest(
        requestDocument));
wordsApi->getFootnotesOnline(request);

GetFormField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFormFieldRequest> request(
    new requests::GetFormFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getFormField(request);

GetFormFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetFormFieldOnlineRequest> request(
    new requests::GetFormFieldOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getFormFieldOnline(request);

GetFormFields.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetFormFieldsRequest> request(
    new requests::GetFormFieldsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getFormFields(request);

GetFormFieldsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetFormFieldsOnlineRequest> request(
    new requests::GetFormFieldsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getFormFieldsOnline(request);

GetHeaderFooter.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetHeaderFooterRequest> request(
    new requests::GetHeaderFooterRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getHeaderFooter(request);

GetHeaderFooterOfSection.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetHeaderFooterOfSectionRequest> request(
    new requests::GetHeaderFooterOfSectionRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0), std::make_shared<int32_t>(0)));
wordsApi->getHeaderFooterOfSection(request);

GetHeaderFooterOfSectionOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetHeaderFooterOfSectionOnlineRequest> request(
    new requests::GetHeaderFooterOfSectionOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<int32_t>(0)));
wordsApi->getHeaderFooterOfSectionOnline(request);

GetHeaderFooterOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetHeaderFooterOnlineRequest> request(
    new requests::GetHeaderFooterOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getHeaderFooterOnline(request);

GetHeaderFooters.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetHeaderFootersRequest> request(
    new requests::GetHeaderFootersRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"")));
wordsApi->getHeaderFooters(request);

GetHeaderFootersOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetHeaderFootersOnlineRequest> request(
    new requests::GetHeaderFootersOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"")));
wordsApi->getHeaderFootersOnline(request);

GetInfo.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetInfoRequest> request(
    new requests::GetInfoRequest());
wordsApi->getInfo(request);

GetList.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetListRequest> request(
    new requests::GetListRequest(
        std::make_shared<std::wstring>(L"TestGetLists.doc"), std::make_shared<int32_t>(1)));
wordsApi->getList(request);

GetListOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetListOnlineRequest> request(
    new requests::GetListOnlineRequest(
        requestDocument, std::make_shared<int32_t>(1)));
wordsApi->getListOnline(request);

GetLists.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetListsRequest> request(
    new requests::GetListsRequest(
        std::make_shared<std::wstring>(L"TestGetLists.doc")));
wordsApi->getLists(request);

GetListsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetListsOnlineRequest> request(
    new requests::GetListsOnlineRequest(
        requestDocument));
wordsApi->getListsOnline(request);

GetOfficeMathObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetOfficeMathObjectRequest> request(
    new requests::GetOfficeMathObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getOfficeMathObject(request);

GetOfficeMathObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetOfficeMathObjectOnlineRequest> request(
    new requests::GetOfficeMathObjectOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getOfficeMathObjectOnline(request);

GetOfficeMathObjects.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetOfficeMathObjectsRequest> request(
    new requests::GetOfficeMathObjectsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getOfficeMathObjects(request);

GetOfficeMathObjectsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetOfficeMathObjectsOnlineRequest> request(
    new requests::GetOfficeMathObjectsOnlineRequest(
        requestDocument));
wordsApi->getOfficeMathObjectsOnline(request);

GetParagraph.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetParagraphRequest> request(
    new requests::GetParagraphRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getParagraph(request);

GetParagraphFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetParagraphFormatRequest> request(
    new requests::GetParagraphFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getParagraphFormat(request);

GetParagraphFormatOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetParagraphFormatOnlineRequest> request(
    new requests::GetParagraphFormatOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getParagraphFormatOnline(request);

GetParagraphListFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetParagraphListFormatRequest> request(
    new requests::GetParagraphListFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getParagraphListFormat(request);

GetParagraphListFormatOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetParagraphListFormatOnlineRequest> request(
    new requests::GetParagraphListFormatOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getParagraphListFormatOnline(request);

GetParagraphOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetParagraphOnlineRequest> request(
    new requests::GetParagraphOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getParagraphOnline(request);

GetParagraphs.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetParagraphsRequest> request(
    new requests::GetParagraphsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getParagraphs(request);

GetParagraphsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetParagraphsOnlineRequest> request(
    new requests::GetParagraphsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0")));
wordsApi->getParagraphsOnline(request);

GetParagraphTabStops.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetParagraphTabStopsRequest> request(
    new requests::GetParagraphTabStopsRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getParagraphTabStops(request);

GetParagraphTabStopsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetParagraphTabStopsOnlineRequest> request(
    new requests::GetParagraphTabStopsOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getParagraphTabStopsOnline(request);

GetPublicKey.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetPublicKeyRequest> request(
    new requests::GetPublicKeyRequest());
wordsApi->getPublicKey(request);

GetRangeText.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetRangeTextRequest> request(
    new requests::GetRangeTextRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"id0.0.0"), std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->getRangeText(request);

GetRangeTextOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::GetRangeTextOnlineRequest> request(
    new requests::GetRangeTextOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"id0.0.0"), std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->getRangeTextOnline(request);

GetRun.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetRunRequest> request(
    new requests::GetRunRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/0"), std::make_shared<int32_t>(0)));
wordsApi->getRun(request);

GetRunFont.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetRunFontRequest> request(
    new requests::GetRunFontRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/0"), std::make_shared<int32_t>(0)));
wordsApi->getRunFont(request);

GetRunFontOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetRunFontOnlineRequest> request(
    new requests::GetRunFontOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/0"), std::make_shared<int32_t>(0)));
wordsApi->getRunFontOnline(request);

GetRunOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetRunOnlineRequest> request(
    new requests::GetRunOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/0"), std::make_shared<int32_t>(0)));
wordsApi->getRunOnline(request);

GetRuns.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetRunsRequest> request(
    new requests::GetRunsRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->getRuns(request);

GetRunsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetRunsOnlineRequest> request(
    new requests::GetRunsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->getRunsOnline(request);

GetSection.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetSectionRequest> request(
    new requests::GetSectionRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getSection(request);

GetSectionOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetSectionOnlineRequest> request(
    new requests::GetSectionOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getSectionOnline(request);

GetSectionPageSetup.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetSectionPageSetupRequest> request(
    new requests::GetSectionPageSetupRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0)));
wordsApi->getSectionPageSetup(request);

GetSectionPageSetupOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetSectionPageSetupOnlineRequest> request(
    new requests::GetSectionPageSetupOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0)));
wordsApi->getSectionPageSetupOnline(request);

GetSections.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetSectionsRequest> request(
    new requests::GetSectionsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getSections(request);

GetSectionsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetSectionsOnlineRequest> request(
    new requests::GetSectionsOnlineRequest(
        requestDocument));
wordsApi->getSectionsOnline(request);

GetStructuredDocumentTag.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetStructuredDocumentTagRequest> request(
    new requests::GetStructuredDocumentTagRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->getStructuredDocumentTag(request);

GetStructuredDocumentTagOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetStructuredDocumentTagOnlineRequest> request(
    new requests::GetStructuredDocumentTagOnlineRequest(
        requestDocument, std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->getStructuredDocumentTagOnline(request);

GetStructuredDocumentTags.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetStructuredDocumentTagsRequest> request(
    new requests::GetStructuredDocumentTagsRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->getStructuredDocumentTags(request);

GetStructuredDocumentTagsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetStructuredDocumentTagsOnlineRequest> request(
    new requests::GetStructuredDocumentTagsOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->getStructuredDocumentTagsOnline(request);

GetStyle.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetStyleRequest> request(
    new requests::GetStyleRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"Heading 1")));
wordsApi->getStyle(request);

GetStyleFromDocumentElement.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetStyleFromDocumentElementRequest> request(
    new requests::GetStyleFromDocumentElementRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/1/paragraphFormat")));
wordsApi->getStyleFromDocumentElement(request);

GetStyleFromDocumentElementOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetStyleFromDocumentElementOnlineRequest> request(
    new requests::GetStyleFromDocumentElementOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/1/paragraphFormat")));
wordsApi->getStyleFromDocumentElementOnline(request);

GetStyleOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetStyleOnlineRequest> request(
    new requests::GetStyleOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"Heading 1")));
wordsApi->getStyleOnline(request);

GetStyles.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetStylesRequest> request(
    new requests::GetStylesRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getStyles(request);

GetStylesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetStylesOnlineRequest> request(
    new requests::GetStylesOnlineRequest(
        requestDocument));
wordsApi->getStylesOnline(request);

GetTable.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTableRequest> request(
    new requests::GetTableRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(1)));
wordsApi->getTable(request);

GetTableCell.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTableCellRequest> request(
    new requests::GetTableCellRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->getTableCell(request);

GetTableCellFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTableCellFormatRequest> request(
    new requests::GetTableCellFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->getTableCellFormat(request);

GetTableCellFormatOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTableCellFormatOnlineRequest> request(
    new requests::GetTableCellFormatOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->getTableCellFormatOnline(request);

GetTableCellOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTableCellOnlineRequest> request(
    new requests::GetTableCellOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), std::make_shared<int32_t>(0)));
wordsApi->getTableCellOnline(request);

GetTableOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTableOnlineRequest> request(
    new requests::GetTableOnlineRequest(
        requestDocument, std::make_shared<int32_t>(1)));
wordsApi->getTableOnline(request);

GetTableProperties.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTablePropertiesRequest> request(
    new requests::GetTablePropertiesRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(1)));
wordsApi->getTableProperties(request);

GetTablePropertiesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTablePropertiesOnlineRequest> request(
    new requests::GetTablePropertiesOnlineRequest(
        requestDocument, std::make_shared<int32_t>(1)));
wordsApi->getTablePropertiesOnline(request);

GetTableRow.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTableRowRequest> request(
    new requests::GetTableRowRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"tables/1"), std::make_shared<int32_t>(0)));
wordsApi->getTableRow(request);

GetTableRowFormat.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTableRowFormatRequest> request(
    new requests::GetTableRowFormatRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2"), std::make_shared<int32_t>(0)));
wordsApi->getTableRowFormat(request);

GetTableRowFormatOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTableRowFormatOnlineRequest> request(
    new requests::GetTableRowFormatOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2"), std::make_shared<int32_t>(0)));
wordsApi->getTableRowFormatOnline(request);

GetTableRowOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTableRowOnlineRequest> request(
    new requests::GetTableRowOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"tables/1"), std::make_shared<int32_t>(0)));
wordsApi->getTableRowOnline(request);

GetTables.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::GetTablesRequest> request(
    new requests::GetTablesRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->getTables(request);

GetTablesOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::GetTablesOnlineRequest> request(
    new requests::GetTablesOnlineRequest(
        requestDocument));
wordsApi->getTablesOnline(request);

InsertBookmark.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestBookmarkStartRange = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestBookmarkStartRange->setNodeId(std::make_shared<std::wstring>(L"0.0.0.0"));
requestBookmarkStartRange->setOffset(std::make_shared<int32_t>(0));
auto requestBookmarkEndRange = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestBookmarkEndRange->setNodeId(std::make_shared<std::wstring>(L"0.0.0.0"));
requestBookmarkEndRange->setOffset(std::make_shared<int32_t>(0));
auto requestBookmark = std::make_shared<aspose::words::cloud::models::BookmarkInsert>();
requestBookmark->setStartRange(requestBookmarkStartRange);
requestBookmark->setEndRange(requestBookmarkEndRange);
requestBookmark->setName(std::make_shared<std::wstring>(L"new_bookmark"));
requestBookmark->setText(std::make_shared<std::wstring>(L"Some text"));
std::shared_ptr<requests::InsertBookmarkRequest> insertRequest(
    new requests::InsertBookmarkRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestBookmark));
wordsApi->insertBookmark(insertRequest);

InsertBookmarkOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestBookmarkStartRange = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestBookmarkStartRange->setNodeId(std::make_shared<std::wstring>(L"0.0.0.0"));
requestBookmarkStartRange->setOffset(std::make_shared<int32_t>(0));
auto requestBookmarkEndRange = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestBookmarkEndRange->setNodeId(std::make_shared<std::wstring>(L"0.0.0.0"));
requestBookmarkEndRange->setOffset(std::make_shared<int32_t>(0));
auto requestBookmark = std::make_shared<aspose::words::cloud::models::BookmarkInsert>();
requestBookmark->setStartRange(requestBookmarkStartRange);
requestBookmark->setEndRange(requestBookmarkEndRange);
requestBookmark->setName(std::make_shared<std::wstring>(L"new_bookmark"));
requestBookmark->setText(std::make_shared<std::wstring>(L"Some text"));
std::shared_ptr<requests::InsertBookmarkOnlineRequest> insertRequest(
    new requests::InsertBookmarkOnlineRequest(
        requestDocument, requestBookmark));
wordsApi->insertBookmarkOnline(insertRequest);

InsertComment.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCommentRangeStart = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeStart->setNodeId(std::make_shared<std::wstring>(L"0.3.0.3"));
requestCommentRangeStart->setOffset(std::make_shared<int32_t>(0));
auto requestCommentRangeEnd = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeEnd->setNodeId(std::make_shared<std::wstring>(L"0.3.0.3"));
requestCommentRangeEnd->setOffset(std::make_shared<int32_t>(0));
auto requestComment = std::make_shared<aspose::words::cloud::models::CommentInsert>();
requestComment->setRangeStart(requestCommentRangeStart);
requestComment->setRangeEnd(requestCommentRangeEnd);
requestComment->setInitial(std::make_shared<std::wstring>(L"IA"));
requestComment->setAuthor(std::make_shared<std::wstring>(L"John Doe"));
requestComment->setText(std::make_shared<std::wstring>(L"A new Comment"));
std::shared_ptr<requests::InsertCommentRequest> insertRequest(
    new requests::InsertCommentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestComment));
wordsApi->insertComment(insertRequest);

InsertCommentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestCommentRangeStart = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeStart->setNodeId(std::make_shared<std::wstring>(L"0.3.0.3"));
requestCommentRangeStart->setOffset(std::make_shared<int32_t>(0));
auto requestCommentRangeEnd = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeEnd->setNodeId(std::make_shared<std::wstring>(L"0.3.0.3"));
requestCommentRangeEnd->setOffset(std::make_shared<int32_t>(0));
auto requestComment = std::make_shared<aspose::words::cloud::models::CommentInsert>();
requestComment->setRangeStart(requestCommentRangeStart);
requestComment->setRangeEnd(requestCommentRangeEnd);
requestComment->setInitial(std::make_shared<std::wstring>(L"IA"));
requestComment->setAuthor(std::make_shared<std::wstring>(L"John Doe"));
requestComment->setText(std::make_shared<std::wstring>(L"A new Comment"));
std::shared_ptr<requests::InsertCommentOnlineRequest> insertRequest(
    new requests::InsertCommentOnlineRequest(
        requestDocument, requestComment));
wordsApi->insertCommentOnline(insertRequest);

InsertCustomXmlPart.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCustomXmlPart = std::make_shared<aspose::words::cloud::models::CustomXmlPartInsert>();
requestCustomXmlPart->setId(std::make_shared<std::wstring>(L"hello"));
requestCustomXmlPart->setData(std::make_shared<std::wstring>(L"<data>Hello world</data>"));
std::shared_ptr<requests::InsertCustomXmlPartRequest> insertRequest(
    new requests::InsertCustomXmlPartRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestCustomXmlPart));
wordsApi->insertCustomXmlPart(insertRequest);

InsertCustomXmlPartOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestCustomXmlPart = std::make_shared<aspose::words::cloud::models::CustomXmlPartInsert>();
requestCustomXmlPart->setId(std::make_shared<std::wstring>(L"hello"));
requestCustomXmlPart->setData(std::make_shared<std::wstring>(L"<data>Hello world</data>"));
std::shared_ptr<requests::InsertCustomXmlPartOnlineRequest> insertRequest(
    new requests::InsertCustomXmlPartOnlineRequest(
        requestDocument, requestCustomXmlPart));
wordsApi->insertCustomXmlPartOnline(insertRequest);

InsertDrawingObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDrawingObject = std::make_shared<aspose::words::cloud::models::DrawingObjectInsert>();
requestDrawingObject->setHeight(std::make_shared<double>(0));
requestDrawingObject->setLeft(std::make_shared<double>(0));
requestDrawingObject->setTop(std::make_shared<double>(0));
requestDrawingObject->setWidth(std::make_shared<double>(0));
requestDrawingObject->setRelativeHorizontalPosition(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::RelativeHorizontalPosition>(aspose::words::cloud::models::DrawingObjectInsert::RelativeHorizontalPosition::MARGIN));
requestDrawingObject->setRelativeVerticalPosition(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::RelativeVerticalPosition>(aspose::words::cloud::models::DrawingObjectInsert::RelativeVerticalPosition::MARGIN));
requestDrawingObject->setWrapType(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::WrapType>(aspose::words::cloud::models::DrawingObjectInsert::WrapType::INLINE));
auto requestImageFile = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Image.png"), std::istream::binary));
std::shared_ptr<requests::InsertDrawingObjectRequest> insertRequest(
    new requests::InsertDrawingObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestDrawingObject, requestImageFile));
wordsApi->insertDrawingObject(insertRequest);

InsertDrawingObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestDrawingObject = std::make_shared<aspose::words::cloud::models::DrawingObjectInsert>();
requestDrawingObject->setHeight(std::make_shared<double>(0));
requestDrawingObject->setLeft(std::make_shared<double>(0));
requestDrawingObject->setTop(std::make_shared<double>(0));
requestDrawingObject->setWidth(std::make_shared<double>(0));
requestDrawingObject->setRelativeHorizontalPosition(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::RelativeHorizontalPosition>(aspose::words::cloud::models::DrawingObjectInsert::RelativeHorizontalPosition::MARGIN));
requestDrawingObject->setRelativeVerticalPosition(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::RelativeVerticalPosition>(aspose::words::cloud::models::DrawingObjectInsert::RelativeVerticalPosition::MARGIN));
requestDrawingObject->setWrapType(std::make_shared<aspose::words::cloud::models::DrawingObjectInsert::WrapType>(aspose::words::cloud::models::DrawingObjectInsert::WrapType::INLINE));
auto requestImageFile = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Image.png"), std::istream::binary));
std::shared_ptr<requests::InsertDrawingObjectOnlineRequest> insertRequest(
    new requests::InsertDrawingObjectOnlineRequest(
        requestDocument, requestDrawingObject, requestImageFile));
wordsApi->insertDrawingObjectOnline(insertRequest);

InsertField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestField = std::make_shared<aspose::words::cloud::models::FieldInsert>();
requestField->setFieldCode(std::make_shared<std::wstring>(L"{ NUMPAGES }"));
std::shared_ptr<requests::InsertFieldRequest> insertRequest(
    new requests::InsertFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestField));
wordsApi->insertField(insertRequest);

InsertFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestField = std::make_shared<aspose::words::cloud::models::FieldInsert>();
requestField->setFieldCode(std::make_shared<std::wstring>(L"{ NUMPAGES }"));
std::shared_ptr<requests::InsertFieldOnlineRequest> insertRequest(
    new requests::InsertFieldOnlineRequest(
        requestDocument, requestField, std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->insertFieldOnline(insertRequest);

InsertFootnote.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestFootnoteDto = std::make_shared<aspose::words::cloud::models::FootnoteInsert>();
requestFootnoteDto->setFootnoteType(std::make_shared<aspose::words::cloud::models::FootnoteBase::FootnoteType>(aspose::words::cloud::models::FootnoteBase::FootnoteType::ENDNOTE));
requestFootnoteDto->setText(std::make_shared<std::wstring>(L"test endnote"));
std::shared_ptr<requests::InsertFootnoteRequest> insertRequest(
    new requests::InsertFootnoteRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestFootnoteDto));
wordsApi->insertFootnote(insertRequest);

InsertFootnoteOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
auto requestFootnoteDto = std::make_shared<aspose::words::cloud::models::FootnoteInsert>();
requestFootnoteDto->setFootnoteType(std::make_shared<aspose::words::cloud::models::FootnoteBase::FootnoteType>(aspose::words::cloud::models::FootnoteBase::FootnoteType::ENDNOTE));
requestFootnoteDto->setText(std::make_shared<std::wstring>(L"test endnote"));
std::shared_ptr<requests::InsertFootnoteOnlineRequest> insertRequest(
    new requests::InsertFootnoteOnlineRequest(
        requestDocument, requestFootnoteDto));
wordsApi->insertFootnoteOnline(insertRequest);

InsertFormField.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestFormField = std::make_shared<aspose::words::cloud::models::FormFieldTextInput>();
requestFormField->setName(std::make_shared<std::wstring>(L"FullName"));
requestFormField->setEnabled(std::make_shared<bool>(true));
requestFormField->setCalculateOnExit(std::make_shared<bool>(true));
requestFormField->setStatusText(std::make_shared<std::wstring>(L""));
requestFormField->setTextInputType(std::make_shared<aspose::words::cloud::models::FormFieldTextInput::TextInputType>(aspose::words::cloud::models::FormFieldTextInput::TextInputType::REGULAR));
requestFormField->setTextInputDefault(std::make_shared<std::wstring>(L"123"));
requestFormField->setTextInputFormat(std::make_shared<std::wstring>(L"UPPERCASE"));
std::shared_ptr<requests::InsertFormFieldRequest> insertRequest(
    new requests::InsertFormFieldRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestFormField));
wordsApi->insertFormField(insertRequest);

InsertFormFieldOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestFormField = std::make_shared<aspose::words::cloud::models::FormFieldTextInput>();
requestFormField->setName(std::make_shared<std::wstring>(L"FullName"));
requestFormField->setEnabled(std::make_shared<bool>(true));
requestFormField->setCalculateOnExit(std::make_shared<bool>(true));
requestFormField->setStatusText(std::make_shared<std::wstring>(L""));
requestFormField->setTextInputType(std::make_shared<aspose::words::cloud::models::FormFieldTextInput::TextInputType>(aspose::words::cloud::models::FormFieldTextInput::TextInputType::REGULAR));
requestFormField->setTextInputDefault(std::make_shared<std::wstring>(L"123"));
requestFormField->setTextInputFormat(std::make_shared<std::wstring>(L"UPPERCASE"));
std::shared_ptr<requests::InsertFormFieldOnlineRequest> insertRequest(
    new requests::InsertFormFieldOnlineRequest(
        requestDocument, requestFormField, std::make_shared<std::wstring>(L"sections/0/paragraphs/0")));
wordsApi->insertFormFieldOnline(insertRequest);

InsertHeaderFooter.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::InsertHeaderFooterRequest> insertRequest(
    new requests::InsertHeaderFooterRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L""), std::make_shared<std::wstring>(L"FooterEven")));
wordsApi->insertHeaderFooter(insertRequest);

InsertHeaderFooterOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::InsertHeaderFooterOnlineRequest> insertRequest(
    new requests::InsertHeaderFooterOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L""), std::make_shared<std::wstring>(L"FooterEven")));
wordsApi->insertHeaderFooterOnline(insertRequest);

InsertList.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestListInsert = std::make_shared<aspose::words::cloud::models::ListInsert>();
requestListInsert->setTemplate(std::make_shared<aspose::words::cloud::models::ListInsert::Template>(aspose::words::cloud::models::ListInsert::Template::OUTLINE_LEGAL));
std::shared_ptr<requests::InsertListRequest> insertRequest(
    new requests::InsertListRequest(
        std::make_shared<std::wstring>(L"TestGetLists.doc"), requestListInsert));
wordsApi->insertList(insertRequest);

InsertListOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
auto requestListInsert = std::make_shared<aspose::words::cloud::models::ListInsert>();
requestListInsert->setTemplate(std::make_shared<aspose::words::cloud::models::ListInsert::Template>(aspose::words::cloud::models::ListInsert::Template::OUTLINE_LEGAL));
std::shared_ptr<requests::InsertListOnlineRequest> insertRequest(
    new requests::InsertListOnlineRequest(
        requestDocument, requestListInsert));
wordsApi->insertListOnline(insertRequest);

InsertOrUpdateParagraphTabStop.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTabStopInsertDto = std::make_shared<aspose::words::cloud::models::TabStopInsert>();
requestTabStopInsertDto->setAlignment(std::make_shared<aspose::words::cloud::models::TabStopBase::Alignment>(aspose::words::cloud::models::TabStopBase::Alignment::LEFT));
requestTabStopInsertDto->setLeader(std::make_shared<aspose::words::cloud::models::TabStopBase::Leader>(aspose::words::cloud::models::TabStopBase::Leader::NONE));
requestTabStopInsertDto->setPosition(std::make_shared<double>(100.0));
std::shared_ptr<requests::InsertOrUpdateParagraphTabStopRequest> insertRequest(
    new requests::InsertOrUpdateParagraphTabStopRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0), requestTabStopInsertDto));
wordsApi->insertOrUpdateParagraphTabStop(insertRequest);

InsertOrUpdateParagraphTabStopOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestTabStopInsertDto = std::make_shared<aspose::words::cloud::models::TabStopInsert>();
requestTabStopInsertDto->setAlignment(std::make_shared<aspose::words::cloud::models::TabStopBase::Alignment>(aspose::words::cloud::models::TabStopBase::Alignment::LEFT));
requestTabStopInsertDto->setLeader(std::make_shared<aspose::words::cloud::models::TabStopBase::Leader>(aspose::words::cloud::models::TabStopBase::Leader::NONE));
requestTabStopInsertDto->setPosition(std::make_shared<double>(72));
std::shared_ptr<requests::InsertOrUpdateParagraphTabStopOnlineRequest> insertRequest(
    new requests::InsertOrUpdateParagraphTabStopOnlineRequest(
        requestDocument, requestTabStopInsertDto, std::make_shared<int32_t>(0)));
wordsApi->insertOrUpdateParagraphTabStopOnline(insertRequest);

InsertPageNumbers.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestPageNumber = std::make_shared<aspose::words::cloud::models::PageNumber>();
requestPageNumber->setAlignment(std::make_shared<std::wstring>(L"center"));
requestPageNumber->setFormat(std::make_shared<std::wstring>(L"{PAGE} of {NUMPAGES}"));
std::shared_ptr<requests::InsertPageNumbersRequest> insertRequest(
    new requests::InsertPageNumbersRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestPageNumber));
wordsApi->insertPageNumbers(insertRequest);

InsertPageNumbersOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestPageNumber = std::make_shared<aspose::words::cloud::models::PageNumber>();
requestPageNumber->setAlignment(std::make_shared<std::wstring>(L"center"));
requestPageNumber->setFormat(std::make_shared<std::wstring>(L"{PAGE} of {NUMPAGES}"));
std::shared_ptr<requests::InsertPageNumbersOnlineRequest> insertRequest(
    new requests::InsertPageNumbersOnlineRequest(
        requestDocument, requestPageNumber));
wordsApi->insertPageNumbersOnline(insertRequest);

InsertParagraph.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestParagraph = std::make_shared<aspose::words::cloud::models::ParagraphInsert>();
requestParagraph->setText(std::make_shared<std::wstring>(L"This is a new paragraph for your document"));
std::shared_ptr<requests::InsertParagraphRequest> insertRequest(
    new requests::InsertParagraphRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestParagraph));
wordsApi->insertParagraph(insertRequest);

InsertParagraphOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestParagraph = std::make_shared<aspose::words::cloud::models::ParagraphInsert>();
requestParagraph->setText(std::make_shared<std::wstring>(L"This is a new paragraph for your document"));
std::shared_ptr<requests::InsertParagraphOnlineRequest> insertRequest(
    new requests::InsertParagraphOnlineRequest(
        requestDocument, requestParagraph, std::make_shared<std::wstring>(L"sections/0")));
wordsApi->insertParagraphOnline(insertRequest);

InsertRun.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestRun = std::make_shared<aspose::words::cloud::models::RunInsert>();
requestRun->setText(std::make_shared<std::wstring>(L"run with text"));
std::shared_ptr<requests::InsertRunRequest> insertRequest(
    new requests::InsertRunRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"paragraphs/1"), requestRun));
wordsApi->insertRun(insertRequest);

InsertRunOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
auto requestRun = std::make_shared<aspose::words::cloud::models::RunInsert>();
requestRun->setText(std::make_shared<std::wstring>(L"run with text"));
std::shared_ptr<requests::InsertRunOnlineRequest> insertRequest(
    new requests::InsertRunOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"paragraphs/1"), requestRun));
wordsApi->insertRunOnline(insertRequest);

InsertStructuredDocumentTag.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestStructuredDocumentTag = std::make_shared<aspose::words::cloud::models::StructuredDocumentTagInsert>();
requestStructuredDocumentTag->setSdtType(std::make_shared<aspose::words::cloud::models::StructuredDocumentTag::SdtType>(aspose::words::cloud::models::StructuredDocumentTag::SdtType::COMBO_BOX));
requestStructuredDocumentTag->setLevel(std::make_shared<aspose::words::cloud::models::StructuredDocumentTag::Level>(aspose::words::cloud::models::StructuredDocumentTag::Level::INLINE));
std::shared_ptr<requests::InsertStructuredDocumentTagRequest> insertRequest(
    new requests::InsertStructuredDocumentTagRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestStructuredDocumentTag, std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->insertStructuredDocumentTag(insertRequest);

InsertStructuredDocumentTagOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestStructuredDocumentTag = std::make_shared<aspose::words::cloud::models::StructuredDocumentTagInsert>();
requestStructuredDocumentTag->setSdtType(std::make_shared<aspose::words::cloud::models::StructuredDocumentTag::SdtType>(aspose::words::cloud::models::StructuredDocumentTag::SdtType::COMBO_BOX));
requestStructuredDocumentTag->setLevel(std::make_shared<aspose::words::cloud::models::StructuredDocumentTag::Level>(aspose::words::cloud::models::StructuredDocumentTag::Level::INLINE));
std::shared_ptr<requests::InsertStructuredDocumentTagOnlineRequest> insertRequest(
    new requests::InsertStructuredDocumentTagOnlineRequest(
        requestDocument, requestStructuredDocumentTag, std::make_shared<std::wstring>(L"sections/0/body/paragraphs/0")));
wordsApi->insertStructuredDocumentTagOnline(insertRequest);

InsertStyle.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestStyleInsert = std::make_shared<aspose::words::cloud::models::StyleInsert>();
requestStyleInsert->setStyleName(std::make_shared<std::wstring>(L"My Style"));
requestStyleInsert->setStyleType(std::make_shared<aspose::words::cloud::models::StyleInsert::StyleType>(aspose::words::cloud::models::StyleInsert::StyleType::PARAGRAPH));
std::shared_ptr<requests::InsertStyleRequest> insertRequest(
    new requests::InsertStyleRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestStyleInsert));
wordsApi->insertStyle(insertRequest);

InsertStyleOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestStyleInsert = std::make_shared<aspose::words::cloud::models::StyleInsert>();
requestStyleInsert->setStyleName(std::make_shared<std::wstring>(L"My Style"));
requestStyleInsert->setStyleType(std::make_shared<aspose::words::cloud::models::StyleInsert::StyleType>(aspose::words::cloud::models::StyleInsert::StyleType::PARAGRAPH));
std::shared_ptr<requests::InsertStyleOnlineRequest> insertRequest(
    new requests::InsertStyleOnlineRequest(
        requestDocument, requestStyleInsert));
wordsApi->insertStyleOnline(insertRequest);

InsertTable.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestTable = std::make_shared<aspose::words::cloud::models::TableInsert>();
requestTable->setColumnsCount(std::make_shared<int32_t>(5));
requestTable->setRowsCount(std::make_shared<int32_t>(4));
std::shared_ptr<requests::InsertTableRequest> insertRequest(
    new requests::InsertTableRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestTable));
wordsApi->insertTable(insertRequest);

InsertTableCell.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCell = std::make_shared<aspose::words::cloud::models::TableCellInsert>();

std::shared_ptr<requests::InsertTableCellRequest> insertRequest(
    new requests::InsertTableCellRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), requestCell));
wordsApi->insertTableCell(insertRequest);

InsertTableCellOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestCell = std::make_shared<aspose::words::cloud::models::TableCellInsert>();

std::shared_ptr<requests::InsertTableCellOnlineRequest> insertRequest(
    new requests::InsertTableCellOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2/rows/0"), requestCell));
wordsApi->insertTableCellOnline(insertRequest);

InsertTableOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestTable = std::make_shared<aspose::words::cloud::models::TableInsert>();
requestTable->setColumnsCount(std::make_shared<int32_t>(5));
requestTable->setRowsCount(std::make_shared<int32_t>(4));
std::shared_ptr<requests::InsertTableOnlineRequest> insertRequest(
    new requests::InsertTableOnlineRequest(
        requestDocument, requestTable));
wordsApi->insertTableOnline(insertRequest);

InsertTableRow.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestRow = std::make_shared<aspose::words::cloud::models::TableRowInsert>();
requestRow->setColumnsCount(std::make_shared<int32_t>(5));
std::shared_ptr<requests::InsertTableRowRequest> insertRequest(
    new requests::InsertTableRowRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"sections/0/tables/2"), requestRow));
wordsApi->insertTableRow(insertRequest);

InsertTableRowOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestRow = std::make_shared<aspose::words::cloud::models::TableRowInsert>();
requestRow->setColumnsCount(std::make_shared<int32_t>(5));
std::shared_ptr<requests::InsertTableRowOnlineRequest> insertRequest(
    new requests::InsertTableRowOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"sections/0/tables/2"), requestRow));
wordsApi->insertTableRowOnline(insertRequest);

InsertWatermarkImage.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::InsertWatermarkImageRequest> insertRequest(
    new requests::InsertWatermarkImageRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), nullptr, std::make_shared<std::wstring>(L"Sample.png")));
wordsApi->insertWatermarkImage(insertRequest);

InsertWatermarkImageOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestImageFile = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Image.png"), std::istream::binary));
std::shared_ptr<requests::InsertWatermarkImageOnlineRequest> insertRequest(
    new requests::InsertWatermarkImageOnlineRequest(
        requestDocument, requestImageFile));
wordsApi->insertWatermarkImageOnline(insertRequest);

InsertWatermarkText.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestWatermarkText = std::make_shared<aspose::words::cloud::models::WatermarkText>();
requestWatermarkText->setText(std::make_shared<std::wstring>(L"This is the text"));
requestWatermarkText->setRotationAngle(std::make_shared<double>(90.0));
std::shared_ptr<requests::InsertWatermarkTextRequest> insertRequest(
    new requests::InsertWatermarkTextRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestWatermarkText));
wordsApi->insertWatermarkText(insertRequest);

InsertWatermarkTextOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestWatermarkText = std::make_shared<aspose::words::cloud::models::WatermarkText>();
requestWatermarkText->setText(std::make_shared<std::wstring>(L"This is the text"));
requestWatermarkText->setRotationAngle(std::make_shared<double>(90));
std::shared_ptr<requests::InsertWatermarkTextOnlineRequest> insertRequest(
    new requests::InsertWatermarkTextOnlineRequest(
        requestDocument, requestWatermarkText));
wordsApi->insertWatermarkTextOnline(insertRequest);

LinkHeaderFootersToPrevious.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::LinkHeaderFootersToPreviousRequest> linkHeaderFootersToPrevious(
    new requests::LinkHeaderFootersToPreviousRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(1)));
wordsApi->linkHeaderFootersToPrevious(linkHeaderFootersToPrevious);

LoadWebDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDataSaveOptions = std::make_shared<aspose::words::cloud::models::DocSaveOptionsData>();
requestDataSaveOptions->setFileName(std::make_shared<std::wstring>(L"google.doc"));
requestDataSaveOptions->setDmlEffectsRenderingMode(std::make_shared<aspose::words::cloud::models::SaveOptionsData::DmlEffectsRenderingMode>(aspose::words::cloud::models::SaveOptionsData::DmlEffectsRenderingMode::NONE));
requestDataSaveOptions->setDmlRenderingMode(std::make_shared<aspose::words::cloud::models::SaveOptionsData::DmlRenderingMode>(aspose::words::cloud::models::SaveOptionsData::DmlRenderingMode::DRAWING_ML));
requestDataSaveOptions->setUpdateSdtContent(std::make_shared<bool>(false));
requestDataSaveOptions->setZipOutput(std::make_shared<bool>(false));
auto requestData = std::make_shared<aspose::words::cloud::models::LoadWebDocumentData>();
requestData->setLoadingDocumentUrl(std::make_shared<std::wstring>(L"http://google.com"));
requestData->setSaveOptions(requestDataSaveOptions);
std::shared_ptr<requests::LoadWebDocumentRequest> loadRequest(
    new requests::LoadWebDocumentRequest(
        requestData));
wordsApi->loadWebDocument(loadRequest);

MoveFile.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::MoveFileRequest> moveRequest(
    new requests::MoveFileRequest(
        std::make_shared<std::wstring>(L"MoveFileSample.docx"), std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->moveFile(moveRequest);

MoveFolder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::MoveFolderRequest> moveRequest(
    new requests::MoveFolderRequest(
        std::make_shared<std::wstring>(L"/TestMoveFolderDest_Sample"), std::make_shared<std::wstring>(L"/TestMoveFolderSrc")));
wordsApi->moveFolder(moveRequest);

OptimizeDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestOptions = std::make_shared<aspose::words::cloud::models::OptimizationOptions>();
requestOptions->setMsWordVersion(std::make_shared<aspose::words::cloud::models::OptimizationOptions::MsWordVersion>(aspose::words::cloud::models::OptimizationOptions::MsWordVersion::WORD2002));
std::shared_ptr<requests::OptimizeDocumentRequest> optimizeRequest(
    new requests::OptimizeDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestOptions));
wordsApi->optimizeDocument(optimizeRequest);

OptimizeDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestOptions = std::make_shared<aspose::words::cloud::models::OptimizationOptions>();
requestOptions->setMsWordVersion(std::make_shared<aspose::words::cloud::models::OptimizationOptions::MsWordVersion>(aspose::words::cloud::models::OptimizationOptions::MsWordVersion::WORD2002));
std::shared_ptr<requests::OptimizeDocumentOnlineRequest> optimizeRequest(
    new requests::OptimizeDocumentOnlineRequest(
        requestDocument, requestOptions));
wordsApi->optimizeDocumentOnline(optimizeRequest);

ProtectDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestProtectionRequest = std::make_shared<aspose::words::cloud::models::ProtectionRequest>();
requestProtectionRequest->setPassword(std::make_shared<std::wstring>(L"123"));
requestProtectionRequest->setProtectionType(std::make_shared<std::wstring>(L"ReadOnly"));
std::shared_ptr<requests::ProtectDocumentRequest> protectRequest(
    new requests::ProtectDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestProtectionRequest));
wordsApi->protectDocument(protectRequest);

ProtectDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestProtectionRequest = std::make_shared<aspose::words::cloud::models::ProtectionRequest>();
requestProtectionRequest->setNewPassword(std::make_shared<std::wstring>(L"123"));
std::shared_ptr<requests::ProtectDocumentOnlineRequest> protectRequest(
    new requests::ProtectDocumentOnlineRequest(
        requestDocument, requestProtectionRequest));
wordsApi->protectDocumentOnline(protectRequest);

RejectAllRevisions.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RejectAllRevisionsRequest> rejectRequest(
    new requests::RejectAllRevisionsRequest(
        std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->rejectAllRevisions(rejectRequest);

RejectAllRevisionsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RejectAllRevisionsOnlineRequest> rejectRequest(
    new requests::RejectAllRevisionsOnlineRequest(
        requestDocument));
wordsApi->rejectAllRevisionsOnline(rejectRequest);

RemoveRange.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RemoveRangeRequest> removeRequest(
    new requests::RemoveRangeRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"id0.0.0"), std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->removeRange(removeRequest);

RemoveRangeOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
std::shared_ptr<requests::RemoveRangeOnlineRequest> removeRequest(
    new requests::RemoveRangeOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"id0.0.0"), std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->removeRangeOnline(removeRequest);

RenderDrawingObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RenderDrawingObjectRequest> renderRequest(
    new requests::RenderDrawingObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderDrawingObject(renderRequest);

RenderDrawingObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RenderDrawingObjectOnlineRequest> renderRequest(
    new requests::RenderDrawingObjectOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0), std::make_shared<std::wstring>(L"sections/0")));
wordsApi->renderDrawingObjectOnline(renderRequest);

RenderMathObject.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RenderMathObjectRequest> renderRequest(
    new requests::RenderMathObjectRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderMathObject(renderRequest);

RenderMathObjectOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RenderMathObjectOnlineRequest> renderRequest(
    new requests::RenderMathObjectOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderMathObjectOnline(renderRequest);

RenderPage.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RenderPageRequest> renderRequest(
    new requests::RenderPageRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(1), std::make_shared<std::wstring>(L"jpg")));
wordsApi->renderPage(renderRequest);

RenderPageOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RenderPageOnlineRequest> renderRequest(
    new requests::RenderPageOnlineRequest(
        requestDocument, std::make_shared<int32_t>(1), std::make_shared<std::wstring>(L"jpg")));
wordsApi->renderPageOnline(renderRequest);

RenderParagraph.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RenderParagraphRequest> renderRequest(
    new requests::RenderParagraphRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderParagraph(renderRequest);

RenderParagraphOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RenderParagraphOnlineRequest> renderRequest(
    new requests::RenderParagraphOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderParagraphOnline(renderRequest);

RenderTable.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::RenderTableRequest> renderRequest(
    new requests::RenderTableRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderTable(renderRequest);

RenderTableOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::RenderTableOnlineRequest> renderRequest(
    new requests::RenderTableOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(0)));
wordsApi->renderTableOnline(renderRequest);

ReplaceText.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestReplaceText = std::make_shared<aspose::words::cloud::models::ReplaceTextParameters>();
requestReplaceText->setOldValue(std::make_shared<std::wstring>(L"Testing"));
requestReplaceText->setNewValue(std::make_shared<std::wstring>(L"Aspose testing"));
std::shared_ptr<requests::ReplaceTextRequest> replaceRequest(
    new requests::ReplaceTextRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestReplaceText));
wordsApi->replaceText(replaceRequest);

ReplaceTextOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestReplaceText = std::make_shared<aspose::words::cloud::models::ReplaceTextParameters>();
requestReplaceText->setOldValue(std::make_shared<std::wstring>(L"aspose"));
requestReplaceText->setNewValue(std::make_shared<std::wstring>(L"aspose new"));
std::shared_ptr<requests::ReplaceTextOnlineRequest> replaceRequest(
    new requests::ReplaceTextOnlineRequest(
        requestDocument, requestReplaceText));
wordsApi->replaceTextOnline(replaceRequest);

ReplaceWithText.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestRangeText = std::make_shared<aspose::words::cloud::models::ReplaceRange>();
requestRangeText->setText(std::make_shared<std::wstring>(L"Replaced header"));
std::shared_ptr<requests::ReplaceWithTextRequest> replaceRequest(
    new requests::ReplaceWithTextRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"id0.0.0"), requestRangeText, std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->replaceWithText(replaceRequest);

ReplaceWithTextOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
auto requestRangeText = std::make_shared<aspose::words::cloud::models::ReplaceRange>();
requestRangeText->setText(std::make_shared<std::wstring>(L"Replaced header"));
std::shared_ptr<requests::ReplaceWithTextOnlineRequest> replaceRequest(
    new requests::ReplaceWithTextOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"id0.0.0"), requestRangeText, std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->replaceWithTextOnline(replaceRequest);

ResetCache.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::ResetCacheRequest> resetRequest(
    new requests::ResetCacheRequest());
wordsApi->resetCache(resetRequest);

SaveAs.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestSaveOptionsData = std::make_shared<aspose::words::cloud::models::DocxSaveOptionsData>();
requestSaveOptionsData->setFileName(std::make_shared<std::wstring>(L"FromPdfToDoc.docx"));
std::shared_ptr<requests::SaveAsRequest> saveRequest(
    new requests::SaveAsRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestSaveOptionsData));
wordsApi->saveAs(saveRequest);

SaveAsOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"test_multi_pages.docx"), std::istream::binary));
auto requestSaveOptionsData = std::make_shared<aspose::words::cloud::models::HtmlSaveOptionsData>();
requestSaveOptionsData->setFileName(std::make_shared<std::wstring>(L"/TestSaveAsHtml.html"));
requestSaveOptionsData->setCssStyleSheetType(std::make_shared<aspose::words::cloud::models::HtmlSaveOptionsData::CssStyleSheetType>(aspose::words::cloud::models::HtmlSaveOptionsData::CssStyleSheetType::EXTERNAL));
requestSaveOptionsData->setCssStyleSheetFileName(std::make_shared<std::wstring>(L"/TestSaveAsHtml.css"));
std::shared_ptr<requests::SaveAsOnlineRequest> saveRequest(
    new requests::SaveAsOnlineRequest(
        requestDocument, requestSaveOptionsData));
wordsApi->saveAsOnline(saveRequest);

SaveAsOnline_1.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestSaveOptionsData = std::make_shared<aspose::words::cloud::models::SaveOptionsData>();
requestSaveOptionsData->setSaveFormat(std::make_shared<std::wstring>(L"pdf"));
requestSaveOptionsData->setFileName(std::make_shared<std::wstring>(L"Sample_out.pdf"));
std::shared_ptr<requests::SaveAsOnlineRequest> saveRequest(
    new requests::SaveAsOnlineRequest(
        requestDocument, requestSaveOptionsData));
wordsApi->saveAsOnline(saveRequest);

SaveAsOnline_2.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestSaveOptionsData = std::make_shared<aspose::words::cloud::models::SaveOptionsData>();
requestSaveOptionsData->setSaveFormat(std::make_shared<std::wstring>(L"html"));
requestSaveOptionsData->setFileName(std::make_shared<std::wstring>(L"Sample_out.html"));
std::shared_ptr<requests::SaveAsOnlineRequest> saveRequest(
    new requests::SaveAsOnlineRequest(
        requestDocument, requestSaveOptionsData));
wordsApi->saveAsOnline(saveRequest);

SaveAsRange.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocumentParameters = std::make_shared<aspose::words::cloud::models::RangeDocument>();
requestDocumentParameters->setDocumentName(std::make_shared<std::wstring>(L"NewDocument.docx"));
std::shared_ptr<requests::SaveAsRangeRequest> saveRequest(
    new requests::SaveAsRangeRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"id0.0.0"), requestDocumentParameters, std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->saveAsRange(saveRequest);

SaveAsRangeOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.doc"), std::istream::binary));
auto requestDocumentParameters = std::make_shared<aspose::words::cloud::models::RangeDocument>();
requestDocumentParameters->setDocumentName(std::make_shared<std::wstring>(L"NewDocument.docx"));
std::shared_ptr<requests::SaveAsRangeOnlineRequest> saveRequest(
    new requests::SaveAsRangeOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"id0.0.0"), requestDocumentParameters, std::make_shared<std::wstring>(L"id0.0.1")));
wordsApi->saveAsRangeOnline(saveRequest);

SaveAsTiff.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestSaveOptions = std::make_shared<aspose::words::cloud::models::TiffSaveOptionsData>();
requestSaveOptions->setFileName(std::make_shared<std::wstring>(L"Image.tiff"));
std::shared_ptr<requests::SaveAsTiffRequest> saveRequest(
    new requests::SaveAsTiffRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestSaveOptions));
wordsApi->saveAsTiff(saveRequest);

SaveAsTiffOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"test_multi_pages.docx"), std::istream::binary));
auto requestSaveOptions = std::make_shared<aspose::words::cloud::models::TiffSaveOptionsData>();
requestSaveOptions->setFileName(std::make_shared<std::wstring>(L"Image.tiff"));
std::shared_ptr<requests::SaveAsTiffOnlineRequest> saveRequest(
    new requests::SaveAsTiffOnlineRequest(
        requestDocument, requestSaveOptions));
wordsApi->saveAsTiffOnline(saveRequest);

Search.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::SearchRequest> searchRequest(
    new requests::SearchRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"aspose")));
wordsApi->search(searchRequest);

SearchOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::SearchOnlineRequest> searchRequest(
    new requests::SearchOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"aspose")));
wordsApi->searchOnline(searchRequest);

SplitDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::shared_ptr<requests::SplitDocumentRequest> splitRequest(
    new requests::SplitDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"text"), std::make_shared<std::wstring>(L"SplitDocument.text"), std::make_shared<int32_t>(1), std::make_shared<int32_t>(2)));
wordsApi->splitDocument(splitRequest);

SplitDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::SplitDocumentOnlineRequest> splitRequest(
    new requests::SplitDocumentOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"text"), std::make_shared<std::wstring>(L"SplitDocument.text"), std::make_shared<int32_t>(1), std::make_shared<int32_t>(2)));
wordsApi->splitDocumentOnline(splitRequest);

SplitDocumentOnline_1.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::SplitDocumentOnlineRequest> splitRequest(
    new requests::SplitDocumentOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"png"), std::make_shared<int32_t>(1), std::make_shared<int32_t>(2)));
wordsApi->splitDocumentOnline(splitRequest);

SplitDocumentOnline_2.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
std::shared_ptr<requests::SplitDocumentOnlineRequest> splitRequest(
    new requests::SplitDocumentOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(L"pdf"), std::make_shared<int32_t>(1), std::make_shared<int32_t>(2)));
wordsApi->splitDocumentOnline(splitRequest);

UnprotectDocument.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestProtectionRequest = std::make_shared<aspose::words::cloud::models::ProtectionRequest>();
requestProtectionRequest->setPassword(std::make_shared<std::wstring>(L"aspose"));
std::shared_ptr<requests::UnprotectDocumentRequest> unprotectRequest(
    new requests::UnprotectDocumentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), requestProtectionRequest));
wordsApi->unprotectDocument(unprotectRequest);

UnprotectDocumentOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestProtectionRequest = std::make_shared<aspose::words::cloud::models::ProtectionRequest>();
requestProtectionRequest->setPassword(std::make_shared<std::wstring>(L"aspose"));
std::shared_ptr<requests::UnprotectDocumentOnlineRequest> unprotectRequest(
    new requests::UnprotectDocumentOnlineRequest(
        requestDocument, requestProtectionRequest));
wordsApi->unprotectDocumentOnline(unprotectRequest);

UpdateBookmark.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::wstring bookmarkName = L"aspose";

auto requestBookmarkData = std::make_shared<aspose::words::cloud::models::BookmarkData>();
requestBookmarkData->setName(std::make_shared<std::wstring>(bookmarkName));
requestBookmarkData->setText(std::make_shared<std::wstring>(L"This will be the text for Aspose"));
std::shared_ptr<requests::UpdateBookmarkRequest> updateRequest(
    new requests::UpdateBookmarkRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(bookmarkName), requestBookmarkData));
wordsApi->updateBookmark(updateRequest);

UpdateBookmarkOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
std::wstring bookmarkName = L"aspose";

auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestBookmarkData = std::make_shared<aspose::words::cloud::models::BookmarkData>();
requestBookmarkData->setName(std::make_shared<std::wstring>(bookmarkName));
requestBookmarkData->setText(std::make_shared<std::wstring>(L"This will be the text for Aspose"));
std::shared_ptr<requests::UpdateBookmarkOnlineRequest> updateRequest(
    new requests::UpdateBookmarkOnlineRequest(
        requestDocument, std::make_shared<std::wstring>(bookmarkName), requestBookmarkData, std::make_shared<std::wstring>(L"Sample.docx")));
wordsApi->updateBookmarkOnline(updateRequest);

UpdateBorder.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestBorderPropertiesColor = std::make_shared<aspose::words::cloud::models::XmlColor>();
requestBorderPropertiesColor->setWeb(std::make_shared<std::wstring>(L"#AABBCC"));
auto requestBorderProperties = std::make_shared<aspose::words::cloud::models::Border>();
requestBorderProperties->setBorderType(std::make_shared<aspose::words::cloud::models::Border::BorderType>(aspose::words::cloud::models::Border::BorderType::LEFT));
requestBorderProperties->setColor(requestBorderPropertiesColor);
requestBorderProperties->setDistanceFromText(std::make_shared<double>(6.0));
requestBorderProperties->setLineStyle(std::make_shared<aspose::words::cloud::models::Border::LineStyle>(aspose::words::cloud::models::Border::LineStyle::DASH_DOT_STROKER));
requestBorderProperties->setLineWidth(std::make_shared<double>(2.0));
requestBorderProperties->setShadow(std::make_shared<bool>(true));
std::shared_ptr<requests::UpdateBorderRequest> updateRequest(
    new requests::UpdateBorderRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<std::wstring>(L"left"), requestBorderProperties, std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->updateBorder(updateRequest);

UpdateBorderOnline.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestDocument = std::shared_ptr<std::istream>(new std::ifstream(std::filesystem::path(L"Sample.docx"), std::istream::binary));
auto requestBorderPropertiesColor = std::make_shared<aspose::words::cloud::models::XmlColor>();
requestBorderPropertiesColor->setWeb(std::make_shared<std::wstring>(L"#AABBCC"));
auto requestBorderProperties = std::make_shared<aspose::words::cloud::models::Border>();
requestBorderProperties->setBorderType(std::make_shared<aspose::words::cloud::models::Border::BorderType>(aspose::words::cloud::models::Border::BorderType::LEFT));
requestBorderProperties->setColor(requestBorderPropertiesColor);
requestBorderProperties->setDistanceFromText(std::make_shared<double>(6));
requestBorderProperties->setLineStyle(std::make_shared<aspose::words::cloud::models::Border::LineStyle>(aspose::words::cloud::models::Border::LineStyle::DASH_DOT_STROKER));
requestBorderProperties->setLineWidth(std::make_shared<double>(2));
requestBorderProperties->setShadow(std::make_shared<bool>(true));
std::shared_ptr<requests::UpdateBorderOnlineRequest> updateRequest(
    new requests::UpdateBorderOnlineRequest(
        requestDocument, requestBorderProperties, std::make_shared<std::wstring>(L"left"), std::make_shared<std::wstring>(L"tables/1/rows/0/cells/0")));
wordsApi->updateBorderOnline(updateRequest);

UpdateComment.cpp

#include "aspose_words_cloud.h"
using namespace aspose::words::cloud;

auto config = std::make_shared<ApiConfiguration>(/*clientId*/ L"####-####-####-####-####", /*clientSecret*/ L"##################");
auto wordsApi = std::make_shared<WordsApi>(config);
auto requestCommentRangeStart = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeStart->setNodeId(std::make_shared<std::wstring>(L"0.3.0"));
requestCommentRangeStart->setOffset(std::make_shared<int32_t>(0));
auto requestCommentRangeEnd = std::make_shared<aspose::words::cloud::models::NewDocumentPosition>();
requestCommentRangeEnd->setNodeId(std::make_shared<std::wstring>(L"0.3.0"));
requestCommentRangeEnd->setOffset(std::make_shared<int32_t>(0));
auto requestComment = std::make_shared<aspose::words::cloud::models::CommentUpdate>();
requestComment->setRangeStart(requestCommentRangeStart);
requestComment->setRangeEnd(requestCommentRangeEnd);
requestComment->setInitial(std::make_shared<std::wstring>(L"IA"));
requestComment->setAuthor(std::make_shared<std::wstring>(L"John Doe"));
requestComment->setText(std::make_shared<std::wstring>(L"A new Comment"));
std::shared_ptr<requests::UpdateCommentRequest> updateRequest(
    new requests::UpdateCommentRequest(
        std::make_shared<std::wstring>(L"Sample.docx"), std::make_shared<int32_t>(0), requestComment));
wordsApi->updateComment(updateRequest);