!Aspose.Words Cloud for Golang

This Gist contains Golang code samples for Aspose.Words Cloud API

AcceptAllRevisions.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
acceptRequestOptions := map[string]interface{}{}
acceptRequest := &models.AcceptAllRevisionsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: acceptRequestOptions,
}
_, _, _ = wordsApi.AcceptAllRevisions(ctx, acceptRequest)

AcceptAllRevisionsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
acceptRequestOptions := map[string]interface{}{}
acceptRequest := &models.AcceptAllRevisionsOnlineRequest{
    Document: requestDocument,
    Optionals: acceptRequestOptions,
}
_, _, _ = wordsApi.AcceptAllRevisionsOnline(ctx, acceptRequest)

AppendDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
remoteFileName:= "Sample.docx"

requestDocumentListDocumentEntries0FileReference := models.CreateRemoteFileReference(remoteFileName)
requestDocumentListDocumentEntries0 := models.DocumentEntry{
    FileReference: &requestDocumentListDocumentEntries0FileReference,
    ImportFormatMode: ToStringPointer("KeepSourceFormatting"),
}
requestDocumentListDocumentEntries := []models.DocumentEntry{
    requestDocumentListDocumentEntries0,
}
requestDocumentList := models.DocumentEntryList{
    DocumentEntries: requestDocumentListDocumentEntries,
}
appendRequestOptions := map[string]interface{}{}
appendRequest := &models.AppendDocumentRequest{
    Name: ToStringPointer(remoteFileName),
    DocumentList: &requestDocumentList,
    Optionals: appendRequestOptions,
}
_, _, _ = wordsApi.AppendDocument(ctx, appendRequest)

AppendDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
localFile:= "Sample.docx"

requestDocument, _ := os.Open(localFile)
requestDocumentListDocumentEntries0FileReferenceStream := OpenFile(t, localFile)
requestDocumentListDocumentEntries0FileReference := models.CreateLocalFileReference(requestDocumentListDocumentEntries0FileReferenceStream)
requestDocumentListDocumentEntries0 := models.DocumentEntry{
    FileReference: &requestDocumentListDocumentEntries0FileReference,
    ImportFormatMode: ToStringPointer("KeepSourceFormatting"),
}
requestDocumentListDocumentEntries := []models.DocumentEntry{
    requestDocumentListDocumentEntries0,
}
requestDocumentList := models.DocumentEntryList{
    DocumentEntries: requestDocumentListDocumentEntries,
}
appendRequestOptions := map[string]interface{}{}
appendRequest := &models.AppendDocumentOnlineRequest{
    Document: requestDocument,
    DocumentList: &requestDocumentList,
    Optionals: appendRequestOptions,
}
_, _, _ = wordsApi.AppendDocumentOnline(ctx, appendRequest)

ApplyStyleToDocumentElement.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestStyleApply := models.StyleApply{
    StyleName: ToStringPointer("Heading 1"),
}
applyStyleRequestOptions := map[string]interface{}{}
applyStyleRequest := &models.ApplyStyleToDocumentElementRequest{
    Name: ToStringPointer("Sample.docx"),
    StyledNodePath: ToStringPointer("paragraphs/1/paragraphFormat"),
    StyleApply: &requestStyleApply,
    Optionals: applyStyleRequestOptions,
}
_, _, _ = wordsApi.ApplyStyleToDocumentElement(ctx, applyStyleRequest)

ApplyStyleToDocumentElementOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestStyleApply := models.StyleApply{
    StyleName: ToStringPointer("Heading 1"),
}
applyStyleRequestOptions := map[string]interface{}{}
applyStyleRequest := &models.ApplyStyleToDocumentElementOnlineRequest{
    Document: requestDocument,
    StyledNodePath: ToStringPointer("paragraphs/1/paragraphFormat"),
    StyleApply: &requestStyleApply,
    Optionals: applyStyleRequestOptions,
}
_, _, _ = wordsApi.ApplyStyleToDocumentElementOnline(ctx, applyStyleRequest)

BuildReport.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestReportEngineSettingsReportBuildOptions := []string{
    "AllowMissingMembers",
    "RemoveEmptyParagraphs",
}
requestReportEngineSettings := models.ReportEngineSettings{
    DataSourceType: ToStringPointer("Json"),
    ReportBuildOptions: requestReportEngineSettingsReportBuildOptions,
}
buildReportRequestOptions := map[string]interface{}{}
buildReportRequest := &models.BuildReportRequest{
    Name: ToStringPointer("Sample.docx"),
    Data: ToStringPointer("Data.json"),
    ReportEngineSettings: &requestReportEngineSettings,
    Optionals: buildReportRequestOptions,
}
_, _, _ = wordsApi.BuildReport(ctx, buildReportRequest)

BuildReportOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("Sample.docx")
requestReportEngineSettings := models.ReportEngineSettings{
    DataSourceType: ToStringPointer("Json"),
    DataSourceName: ToStringPointer("persons"),
}
buildReportRequestOptions := map[string]interface{}{}
buildReportRequest := &models.BuildReportOnlineRequest{
    Template: requestTemplate,
    Data: ToStringPointer("Data.json"),
    ReportEngineSettings: &requestReportEngineSettings,
    Optionals: buildReportRequestOptions,
}
_, _ = wordsApi.BuildReportOnline(ctx, buildReportRequest)

Classify.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
classifyRequestOptions := map[string]interface{}{"bestClassesCount": "3",}
classifyRequest := &models.ClassifyRequest{
    Text: ToStringPointer("Try text classification"),
    Optionals: classifyRequestOptions,
}
_, _, _ = wordsApi.Classify(ctx, classifyRequest)

ClassifyDocument.Go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
classifyRequestOptions := map[string]interface{}{"bestClassesCount": "3",}
classifyRequest := &models.ClassifyDocumentRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: classifyRequestOptions,
}
_, _, _ = wordsApi.ClassifyDocument(ctx, classifyRequest)

ClassifyDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
classifyRequestOptions := map[string]interface{}{"bestClassesCount": "3",}
classifyRequest := &models.ClassifyDocumentOnlineRequest{
    Document: requestDocument,
    Optionals: classifyRequestOptions,
}
_, _, _ = wordsApi.ClassifyDocumentOnline(ctx, classifyRequest)

CompareDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestCompareData := models.CompareData{
    Author: ToStringPointer("author"),
    ComparingWithDocument: ToStringPointer("TestCompareDocument2.doc"),
    DateTime: ToTimePointer(CreateTime(2015, 10, 26, 0, 0, 0)),
}
compareRequestOptions := map[string]interface{}{"destFileName": "CompareDocumentOut.doc",}
compareRequest := &models.CompareDocumentRequest{
    Name: ToStringPointer("TestCompareDocument1.doc"),
    CompareData: &requestCompareData,
    Optionals: compareRequestOptions,
}
_, _, _ = wordsApi.CompareDocument(ctx, compareRequest)

CompareDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("compareTestDoc1.doc")
requestCompareData := models.CompareData{
    Author: ToStringPointer("author"),
    ComparingWithDocument: ToStringPointer("TestCompareDocument2.doc"),
    DateTime: ToTimePointer(CreateTime(2015, 10, 26, 0, 0, 0)),
}
requestComparingDocument, _ := os.Open("compareTestDoc2.doc")
compareRequestOptions := map[string]interface{}{"comparingDocument": requestComparingDocument,
"destFileName": "CompareDocumentOut.doc",}
compareRequest := &models.CompareDocumentOnlineRequest{
    Document: requestDocument,
    CompareData: &requestCompareData,
    Optionals: compareRequestOptions,
}
_, _, _ = wordsApi.CompareDocumentOnline(ctx, compareRequest)

CompressDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestCompressOptions := models.CompressOptions{
}
compressDocumentOptions := map[string]interface{}{}
compressDocument := &models.CompressDocumentRequest{
    Name: ToStringPointer("Sample.docx"),
    CompressOptions: &requestCompressOptions,
    Optionals: compressDocumentOptions,
}
_, _, _ = wordsApi.CompressDocument(ctx, compressDocument)

CompressDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("TestCompress.docx")
requestCompressOptions := models.CompressOptions{
}
compressDocumentOnlineOptions := map[string]interface{}{}
compressDocumentOnline := &models.CompressDocumentOnlineRequest{
    Document: requestDocument,
    CompressOptions: &requestCompressOptions,
    Optionals: compressDocumentOnlineOptions,
}
_, _, _ = wordsApi.CompressDocumentOnline(ctx, compressDocumentOnline)

config.json

{
  "ClientId": "####-####-####-####-####",
  "ClientSecret": "##################",
  "BaseUrl": "https://api.aspose.cloud"
}

ConvertDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
convertRequestOptions := map[string]interface{}{}
convertRequest := &models.ConvertDocumentRequest{
    Document: requestDocument,
    Format: ToStringPointer("pdf"),
    Optionals: convertRequestOptions,
}
_, _ = wordsApi.ConvertDocument(ctx, convertRequest)

ConvertDocument_1.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
convertRequestOptions := map[string]interface{}{}
convertRequest := &models.ConvertDocumentRequest{
    Document: requestDocument,
    Format: ToStringPointer("pdf"),
    Optionals: convertRequestOptions,
}
_, _ = wordsApi.ConvertDocument(ctx, convertRequest)

ConvertDocument_2.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
convertRequestOptions := map[string]interface{}{}
convertRequest := &models.ConvertDocumentRequest{
    Document: requestDocument,
    Format: ToStringPointer("pdf"),
    Optionals: convertRequestOptions,
}
_, _ = wordsApi.ConvertDocument(ctx, convertRequest)

CopyFile.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
copyRequestOptions := map[string]interface{}{}
copyRequest := &models.CopyFileRequest{
    DestPath: ToStringPointer("Copy.docx"),
    SrcPath: ToStringPointer("Sample.docx"),
    Optionals: copyRequestOptions,
}
_, _ = wordsApi.CopyFile(ctx, copyRequest)

CopyFolder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
folderToCopy:= "/TestCopyFolder"

copyRequestOptions := map[string]interface{}{}
copyRequest := &models.CopyFolderRequest{
    DestPath: ToStringPointer(folderToCopy + "Dest"),
    SrcPath: ToStringPointer(folderToCopy + "Src"),
    Optionals: copyRequestOptions,
}
_, _ = wordsApi.CopyFolder(ctx, copyRequest)

CopyStyle.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestStyleCopy := models.StyleCopy{
    StyleName: ToStringPointer("Heading 1"),
}
copyRequestOptions := map[string]interface{}{}
copyRequest := &models.CopyStyleRequest{
    Name: ToStringPointer("Sample.docx"),
    StyleCopy: &requestStyleCopy,
    Optionals: copyRequestOptions,
}
_, _, _ = wordsApi.CopyStyle(ctx, copyRequest)

CopyStyleOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestStyleCopy := models.StyleCopy{
    StyleName: ToStringPointer("Heading 1"),
}
copyRequestOptions := map[string]interface{}{}
copyRequest := &models.CopyStyleOnlineRequest{
    Document: requestDocument,
    StyleCopy: &requestStyleCopy,
    Optionals: copyRequestOptions,
}
_, _, _ = wordsApi.CopyStyleOnline(ctx, copyRequest)

CopyStylesFromTemplate.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
copyRequestOptions := map[string]interface{}{}
copyRequest := &models.CopyStylesFromTemplateRequest{
    Name: ToStringPointer("Sample.docx"),
    TemplateName: ToStringPointer("StyleTemplate.docx"),
    Optionals: copyRequestOptions,
}
_, _, _ = wordsApi.CopyStylesFromTemplate(ctx, copyRequest)

CreateDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
createRequestOptions := map[string]interface{}{"fileName": "Sample.docx",}
createRequest := &models.CreateDocumentRequest{
    Optionals: createRequestOptions,
}
_, _, _ = wordsApi.CreateDocument(ctx, createRequest)

CreateFolder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
createRequestOptions := map[string]interface{}{}
createRequest := &models.CreateFolderRequest{
    Path: ToStringPointer("/TestCreateFolder"),
    Optionals: createRequestOptions,
}
_, _ = wordsApi.CreateFolder(ctx, createRequest)

CreateOrUpdateDocumentProperty.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestProperty := models.DocumentPropertyCreateOrUpdate{
    Value: ToStringPointer("John Doe"),
}
createRequestOptions := map[string]interface{}{}
createRequest := &models.CreateOrUpdateDocumentPropertyRequest{
    Name: ToStringPointer("Sample.docx"),
    PropertyName: ToStringPointer("AsposeAuthor"),
    Property: &requestProperty,
    Optionals: createRequestOptions,
}
_, _, _ = wordsApi.CreateOrUpdateDocumentProperty(ctx, createRequest)

CreateOrUpdateDocumentPropertyOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestProperty := models.DocumentPropertyCreateOrUpdate{
    Value: ToStringPointer("John Doe"),
}
createRequestOptions := map[string]interface{}{}
createRequest := &models.CreateOrUpdateDocumentPropertyOnlineRequest{
    Document: requestDocument,
    PropertyName: ToStringPointer("AsposeAuthor"),
    Property: &requestProperty,
    Optionals: createRequestOptions,
}
_, _, _ = wordsApi.CreateOrUpdateDocumentPropertyOnline(ctx, createRequest)

DeleteAllParagraphTabStops.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteAllParagraphTabStopsRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteAllParagraphTabStops(ctx, deleteRequest)

DeleteAllParagraphTabStopsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteAllParagraphTabStopsOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteAllParagraphTabStopsOnline(ctx, deleteRequest)

DeleteBookmark.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteBookmarkRequest{
    Name: ToStringPointer("Sample.docx"),
    BookmarkName: ToStringPointer("aspose"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteBookmark(ctx, deleteRequest)

DeleteBookmarkOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteBookmarkOnlineRequest{
    Document: requestDocument,
    BookmarkName: ToStringPointer("aspose"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBookmarkOnline(ctx, deleteRequest)

DeleteBookmarks.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteBookmarksRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteBookmarks(ctx, deleteRequest)

DeleteBookmarksOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteBookmarksOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBookmarksOnline(ctx, deleteRequest)

DeleteBorder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
deleteRequest := &models.DeleteBorderRequest{
    Name: ToStringPointer("Sample.docx"),
    BorderType: ToStringPointer("left"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBorder(ctx, deleteRequest)

DeleteBorderOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
deleteRequest := &models.DeleteBorderOnlineRequest{
    Document: requestDocument,
    BorderType: ToStringPointer("left"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBorderOnline(ctx, deleteRequest)

DeleteBorders.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
deleteRequest := &models.DeleteBordersRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBorders(ctx, deleteRequest)

DeleteBordersOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
deleteRequest := &models.DeleteBordersOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteBordersOnline(ctx, deleteRequest)

DeleteComment.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCommentRequest{
    Name: ToStringPointer("Sample.docx"),
    CommentIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteComment(ctx, deleteRequest)

DeleteCommentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCommentOnlineRequest{
    Document: requestDocument,
    CommentIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteCommentOnline(ctx, deleteRequest)

DeleteComments.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCommentsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteComments(ctx, deleteRequest)

DeleteCommentsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCommentsOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteCommentsOnline(ctx, deleteRequest)

DeleteCustomXmlPart.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCustomXmlPartRequest{
    Name: ToStringPointer("Sample.docx"),
    CustomXmlPartIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteCustomXmlPart(ctx, deleteRequest)

DeleteCustomXmlPartOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCustomXmlPartOnlineRequest{
    Document: requestDocument,
    CustomXmlPartIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteCustomXmlPartOnline(ctx, deleteRequest)

DeleteCustomXmlParts.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCustomXmlPartsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteCustomXmlParts(ctx, deleteRequest)

DeleteCustomXmlPartsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteCustomXmlPartsOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteCustomXmlPartsOnline(ctx, deleteRequest)

DeleteDocumentProperty.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteDocumentPropertyRequest{
    Name: ToStringPointer("Sample.docx"),
    PropertyName: ToStringPointer("testProp"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteDocumentProperty(ctx, deleteRequest)

DeleteDocumentPropertyOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteDocumentPropertyOnlineRequest{
    Document: requestDocument,
    PropertyName: ToStringPointer("testProp"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteDocumentPropertyOnline(ctx, deleteRequest)

DeleteDrawingObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteDrawingObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteDrawingObject(ctx, deleteRequest)

DeleteDrawingObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteDrawingObjectOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteDrawingObjectOnline(ctx, deleteRequest)

DeleteField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteField(ctx, deleteRequest)

DeleteFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{"nodePath": "sections/0/paragraphs/0",}
deleteRequest := &models.DeleteFieldOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteFieldOnline(ctx, deleteRequest)

DeleteFields.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFieldsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteFields(ctx, deleteRequest)

DeleteFieldsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFieldsOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteFieldsOnline(ctx, deleteRequest)

DeleteFile.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFileRequest{
    Path: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteFile(ctx, deleteRequest)

DeleteFolder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFolderRequest{
    Path: ToStringPointer(""),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteFolder(ctx, deleteRequest)

DeleteFootnote.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFootnoteRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteFootnote(ctx, deleteRequest)

DeleteFootnoteOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFootnoteOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteFootnoteOnline(ctx, deleteRequest)

DeleteFormField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteFormFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteFormField(ctx, deleteRequest)

DeleteFormFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{"nodePath": "sections/0",}
deleteRequest := &models.DeleteFormFieldOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteFormFieldOnline(ctx, deleteRequest)

DeleteHeaderFooter.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteHeaderFooterRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionPath: ToStringPointer(""),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteHeaderFooter(ctx, deleteRequest)

DeleteHeaderFooterOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteHeaderFooterOnlineRequest{
    Document: requestDocument,
    SectionPath: ToStringPointer(""),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteHeaderFooterOnline(ctx, deleteRequest)

DeleteHeadersFooters.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteHeadersFootersRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionPath: ToStringPointer(""),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteHeadersFooters(ctx, deleteRequest)

DeleteHeadersFootersOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteHeadersFootersOnlineRequest{
    Document: requestDocument,
    SectionPath: ToStringPointer(""),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteHeadersFootersOnline(ctx, deleteRequest)

DeleteMacros.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteMacrosRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteMacros(ctx, deleteRequest)

DeleteMacrosOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteMacrosOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteMacrosOnline(ctx, deleteRequest)

DeleteOfficeMathObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteOfficeMathObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteOfficeMathObject(ctx, deleteRequest)

DeleteOfficeMathObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteOfficeMathObjectOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteOfficeMathObjectOnline(ctx, deleteRequest)

DeleteParagraph.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteParagraph(ctx, deleteRequest)

DeleteParagraphListFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphListFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteParagraphListFormat(ctx, deleteRequest)

DeleteParagraphListFormatOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphListFormatOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteParagraphListFormatOnline(ctx, deleteRequest)

DeleteParagraphOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteParagraphOnline(ctx, deleteRequest)

DeleteParagraphTabStop.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphTabStopRequest{
    Name: ToStringPointer("Sample.docx"),
    Position: ToFloat64Pointer(72.0),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteParagraphTabStop(ctx, deleteRequest)

DeleteParagraphTabStopOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteParagraphTabStopOnlineRequest{
    Document: requestDocument,
    Position: ToFloat64Pointer(72.0),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteParagraphTabStopOnline(ctx, deleteRequest)

DeleteRun.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteRunRequest{
    Name: ToStringPointer("Sample.docx"),
    ParagraphPath: ToStringPointer("paragraphs/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteRun(ctx, deleteRequest)

DeleteRunOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteRunOnlineRequest{
    Document: requestDocument,
    ParagraphPath: ToStringPointer("paragraphs/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteRunOnline(ctx, deleteRequest)

DeleteSection.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteSectionRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteSection(ctx, deleteRequest)

DeleteSectionOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteSectionOnlineRequest{
    Document: requestDocument,
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteSectionOnline(ctx, deleteRequest)

DeleteStructuredDocumentTag.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
deleteRequest := &models.DeleteStructuredDocumentTagRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteStructuredDocumentTag(ctx, deleteRequest)

DeleteStructuredDocumentTagOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
deleteRequest := &models.DeleteStructuredDocumentTagOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteStructuredDocumentTagOnline(ctx, deleteRequest)

DeleteTable.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(1)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteTable(ctx, deleteRequest)

DeleteTableCell.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableCellRequest{
    Name: ToStringPointer("Sample.docx"),
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteTableCell(ctx, deleteRequest)

DeleteTableCellOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableCellOnlineRequest{
    Document: requestDocument,
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteTableCellOnline(ctx, deleteRequest)

DeleteTableOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(1)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteTableOnline(ctx, deleteRequest)

DeleteTableRow.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableRowRequest{
    Name: ToStringPointer("Sample.docx"),
    TablePath: ToStringPointer("tables/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _ = wordsApi.DeleteTableRow(ctx, deleteRequest)

DeleteTableRowOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteTableRowOnlineRequest{
    Document: requestDocument,
    TablePath: ToStringPointer("tables/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteTableRowOnline(ctx, deleteRequest)

DeleteWatermark.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteWatermarkRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteWatermark(ctx, deleteRequest)

DeleteWatermarkOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
deleteRequestOptions := map[string]interface{}{}
deleteRequest := &models.DeleteWatermarkOnlineRequest{
    Document: requestDocument,
    Optionals: deleteRequestOptions,
}
_, _, _ = wordsApi.DeleteWatermarkOnline(ctx, deleteRequest)

DownloadFile.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
downloadRequestOptions := map[string]interface{}{}
downloadRequest := &models.DownloadFileRequest{
    Path: ToStringPointer("Sample.docx"),
    Optionals: downloadRequestOptions,
}
_, _ = wordsApi.DownloadFile(ctx, downloadRequest)

ExecuteMailMerge.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptionsCurrentUser := models.UserInformation{
    Name: ToStringPointer("SdkTestUser"),
}
requestOptions := models.FieldOptions{
    CurrentUser: &requestOptionsCurrentUser,
}
mailMergeRequestOptions := map[string]interface{}{"data": ReadFile(t, "TestMailMergeData.xml"),
"options": &requestOptions,}
mailMergeRequest := &models.ExecuteMailMergeRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: mailMergeRequestOptions,
}
_, _, _ = wordsApi.ExecuteMailMerge(ctx, mailMergeRequest)

ExecuteMailMerge_2.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
filePath := "SampleMailMergeTemplate.docx"

// Open template
file, err := os.Open(filePath)
if err != nil {
  fmt.Println(err)
}

// Upload template
_, _, err1 := wordsApi.UploadFile(ctx, file, "SampleMailMergeTemplate.docx", nil)

if err1 != nil {
  fmt.Println(err1)
}

var jsonStr = `{
  "storage": "First Storage",
  "data": {
    "root": {
      "data": {
        "format": "html",
        "htmlText": "<html><head><style type="text/css">h2{color:green} .color_red{color:red} .color_green{color:green} .color_magenta{color:magenta} .color_olive{color:olive} .color_teal{color:teal}</style></head><body><h2>Table</h2><table border="2" cellspacing="0" cellpadding="4"><tr><th class="color_red">Column 1</th><th class="color_green">Column 2</th></tr><tr><td class="color_magenta">Value 1.1</td><td class="color_olive">Value 1.2</td></tr><tr><td class="color_teal">Value 2.1</td></tr></table><h2>Div</h2><div class="color_olive">Outer text<div class="color_magenta">Inner text</div>Outer text</div><h2>Image</h2><br/><img src="data:image/gif;base64,iVBORw0KGgoAAAANSUhEUgAAABAAAAAQCAYAAAAf8/9hAAAACXBIWXMAAAsTAAALEwEAmpwYAAADUUlEQVR42lWTWUwTURSGaUtIKY5QweISTUzceDGu0Rj1xURjTNQEE+ODGn0hPhBEQdqZztahBbrAtFih1Fprh9IBiVLLErZSU7BUoS7VqNH44ovx0S0ovdfO4Ez04cw9Ofec7/5zzr15NEnkUxSVFx8ObZ1x7nzHN6z9nOhnzOFwWCnECcKoEFbBRrrp6iF/XRvD0BoplkdTuAiIhtt3P3Fu+jJlKlkM1WoXLFjVeSnpXrC94gV3ciJp1X0L1K7+NtDfvXdpj1TmmUwm8QTfLa867T+ceWTSwO5r5b87XNaDEoBrv3p2Ai+AU1Qh5OiDGS4UXi4roAisQHBiYfJS2obAVPMyELYcGxViOIaKcLaNLXzadej5nBUBPXW6hdYW0z4RQOYUXK2tUfr8QeXL0Kn4JKEBk7QWdtrrLggJJEmoCBxVCf50qIaaa0HABFkEPZaLNnGfwPNFGV0u05Y554bvMQoBPLbxs9t9QydJpHP/KayRbsf+pG1NdgTTgDuGXa8dbS41ZtArxaQYT1WlHVqYaloGOcvJIan4X2MdViTl3vExbS+GPfXlvzzutj1LPch9HrYea59t0YIRtAAO+PQuIWYwNKikYty41Iuk/3TvMzsCB9HcQR7msgzgjZs7Z5rLQPR6PojeJW2d3oDCoG/IlwAYqlexbp/i9eB19ziuBoMoAlrR03YZ0G8+0JFhS8EjuhD6zWfuCTEjppcBOKYX1bwaqA5MM2oYZ4pBy7XjrAyY7sPqU01FcNZW/jtwZeXXVpt5u1RM4JhYzHFBddqz5/28fUU2NwngtVUbZUCE79o6x67/MYiXLiSbS8D9xp1vI7znkLvDK07A5/MiT7mzdxMMAsdMqxaiWDHkgzePigBUXy9KTfdWeVKNSjjPrvv5uKkYxszlIHX7eDLeVfkgbt30bt5eAlOOtT9nLRrI03szrOumOtcb4SrTSj2KKfr4nuUZ7kR8HFPAYXLlYqxRl43TGjjTWAhHCC1MNK/+lWA0cJLRgfsh95G/N1H136z7+BCSuHMuMEGVLo4a1XCKKcuO0WXZBw1FcNighmPWbe8jIeeJpdFiCrkHguWUyM92NBKseBut8T92bfsw66z49IyrHH2T5CvlqeCYUvL/ANIZ7+ohXSdWAAAAAElFTkSuQmCC"></body></html>"
      }
    }
  },
  "destFileName": "Out_SampleMailMergeTemplate.docx"
}`
// Populate map[string]interface{}
jsonMap := make(map[string]interface{})

json.Unmarshal([]byte(jsonStr), &jsonMap)

// Populate mail merge template (The output doc will be saved in cloud storage)
_, response, _ := wordsApi.ExecuteMailMerge(ctx, "SampleMailMergeTemplate.docx", jsonMap)

fmt.Println(response.Status)

ExecuteMailMerge_3.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
filePath := "SampleMailMergeTemplate.docx"

// Open template
file, err := os.Open(filePath)
if err != nil {
  fmt.Println(err)
}

// Upload template
_, _, err1 := wordsApi.UploadFile(ctx, file, "SampleMailMergeTemplate.docx", nil)

if err1 != nil {
  fmt.Println(err1)
}

var jsonStr = `{
  "storage":"First Storage",
  "data": "<Fields><FullName>abc user</FullName><Company>Aspose Pty Ltd</Company><Address>Suite 163</Address><Address2>79 Longueville Road</Address2><City>Lane Cove</City></Fields>",
"loadEncoding":"utf8",
"destFileName":"Out_SampleMailMergeTemplate.docx"    
}`
// Populate map[string]interface{}
jsonMap := make(map[string]interface{})

json.Unmarshal([]byte(jsonStr), &jsonMap)

// Convert Document to html (The output doc will be saved in cloud storage)
_, response, _ := wordsApi.ExecuteMailMerge(ctx, "SampleMailMergeTemplate.docx", jsonMap)

fmt.Println(response.Status)

ExecuteMailMergeOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("Sample.docx")
requestData, _ := os.Open(ReadFile(t, "TestMailMergeData.xml"))
requestOptionsCurrentUser := models.UserInformation{
    Name: ToStringPointer("SdkTestUser"),
}
requestOptions := models.FieldOptions{
    CurrentUser: &requestOptionsCurrentUser,
}
mailMergeRequestOptions := map[string]interface{}{"options": &requestOptions,}
mailMergeRequest := &models.ExecuteMailMergeOnlineRequest{
    Template: requestTemplate,
    Data: requestData,
    Optionals: mailMergeRequestOptions,
}
_, _ = wordsApi.ExecuteMailMergeOnline(ctx, mailMergeRequest)

ExecuteMailMergeOnline_1.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("TestMailMergeWithImages.doc")
requestData, _ := os.Open("MailMergeData.json")
mailMergeRequestOptions := map[string]interface{}{"documentFileName": "Out_TestMailMergeWithImages.doc",}
mailMergeRequest := &models.ExecuteMailMergeOnlineRequest{
    Template: requestTemplate,
    Data: requestData,
    Optionals: mailMergeRequestOptions,
}
_, _ = wordsApi.ExecuteMailMergeOnline(ctx, mailMergeRequest)

ExecuteMailMergeOnline_2.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("template.doc")
requestData, _ := os.Open("TestPostDocumentExecuteMailMerge.txt")
mailMergeRequestOptions := map[string]interface{}{"documentFileName": "Out_PostDocumentExecuteMailMergeWithHTMLData.docx",}
mailMergeRequest := &models.ExecuteMailMergeOnlineRequest{
    Template: requestTemplate,
    Data: requestData,
    Optionals: mailMergeRequestOptions,
}
_, _ = wordsApi.ExecuteMailMergeOnline(ctx, mailMergeRequest)

ExecuteMailMergeOnline_3.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("SampleMailMergeTemplate.docx")
requestData, _ := os.Open("SampleMailMergeTemplateData.xml")
mailMergeRequestOptions := map[string]interface{}{"documentFileName": "Out_SampleMailMergeTemplate.docx",}
mailMergeRequest := &models.ExecuteMailMergeOnlineRequest{
    Template: requestTemplate,
    Data: requestData,
    Optionals: mailMergeRequestOptions,
}
_, _ = wordsApi.ExecuteMailMergeOnline(ctx, mailMergeRequest)

GetAvailableFonts.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetAvailableFontsRequest{
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetAvailableFonts(ctx, request)

GetBookmarkByName.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetBookmarkByNameRequest{
    Name: ToStringPointer("Sample.docx"),
    BookmarkName: ToStringPointer("aspose"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBookmarkByName(ctx, request)

GetBookmarkByNameOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetBookmarkByNameOnlineRequest{
    Document: requestDocument,
    BookmarkName: ToStringPointer("aspose"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBookmarkByNameOnline(ctx, request)

GetBookmarks.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetBookmarksRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBookmarks(ctx, request)

GetBookmarksOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetBookmarksOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBookmarksOnline(ctx, request)

GetBorder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
request := &models.GetBorderRequest{
    Name: ToStringPointer("Sample.docx"),
    BorderType: ToStringPointer("left"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBorder(ctx, request)

GetBorderOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
request := &models.GetBorderOnlineRequest{
    Document: requestDocument,
    BorderType: ToStringPointer("left"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBorderOnline(ctx, request)

GetBorders.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
request := &models.GetBordersRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBorders(ctx, request)

GetBordersOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "tables/1/rows/0/cells/0",}
request := &models.GetBordersOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetBordersOnline(ctx, request)

GetComment.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetCommentRequest{
    Name: ToStringPointer("Sample.docx"),
    CommentIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetComment(ctx, request)

GetCommentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetCommentOnlineRequest{
    Document: requestDocument,
    CommentIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCommentOnline(ctx, request)

GetComments.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetCommentsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetComments(ctx, request)

GetCommentsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetCommentsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCommentsOnline(ctx, request)

GetCustomXmlPart.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetCustomXmlPartRequest{
    Name: ToStringPointer("Sample.docx"),
    CustomXmlPartIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCustomXmlPart(ctx, request)

GetCustomXmlPartOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetCustomXmlPartOnlineRequest{
    Document: requestDocument,
    CustomXmlPartIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCustomXmlPartOnline(ctx, request)

GetCustomXmlParts.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetCustomXmlPartsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCustomXmlParts(ctx, request)

GetCustomXmlPartsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetCustomXmlPartsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetCustomXmlPartsOnline(ctx, request)

GetDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentRequest{
    DocumentName: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocument(ctx, request)

GetDocumentDrawingObjectByIndex.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentDrawingObjectByIndexRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentDrawingObjectByIndex(ctx, request)

GetDocumentDrawingObjectByIndexOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetDocumentDrawingObjectByIndexOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentDrawingObjectByIndexOnline(ctx, request)

GetDocumentDrawingObjectImageData.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentDrawingObjectImageDataRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _ = wordsApi.GetDocumentDrawingObjectImageData(ctx, request)

GetDocumentDrawingObjectImageDataOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetDocumentDrawingObjectImageDataOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _ = wordsApi.GetDocumentDrawingObjectImageDataOnline(ctx, request)

GetDocumentDrawingObjectOleData.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentDrawingObjectOleDataRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _ = wordsApi.GetDocumentDrawingObjectOleData(ctx, request)

GetDocumentDrawingObjectOleDataOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetDocumentDrawingObjectOleDataOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _ = wordsApi.GetDocumentDrawingObjectOleDataOnline(ctx, request)

GetDocumentDrawingObjects.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentDrawingObjectsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentDrawingObjects(ctx, request)

GetDocumentDrawingObjectsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetDocumentDrawingObjectsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentDrawingObjectsOnline(ctx, request)

GetDocumentFieldNames.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentFieldNamesRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentFieldNames(ctx, request)

GetDocumentFieldNamesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTemplate, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"useNonMergeFields": true,}
request := &models.GetDocumentFieldNamesOnlineRequest{
    Template: requestTemplate,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentFieldNamesOnline(ctx, request)

GetDocumentHyperlinkByIndex.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentHyperlinkByIndexRequest{
    Name: ToStringPointer("Sample.docx"),
    HyperlinkIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentHyperlinkByIndex(ctx, request)

GetDocumentHyperlinkByIndexOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentHyperlinkByIndexOnlineRequest{
    Document: requestDocument,
    HyperlinkIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentHyperlinkByIndexOnline(ctx, request)

GetDocumentHyperlinks.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentHyperlinksRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentHyperlinks(ctx, request)

GetDocumentHyperlinksOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentHyperlinksOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentHyperlinksOnline(ctx, request)

GetDocumentProperties.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentPropertiesRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentProperties(ctx, request)

GetDocumentPropertiesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentPropertiesOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentPropertiesOnline(ctx, request)

GetDocumentProperty.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentPropertyRequest{
    Name: ToStringPointer("Sample.docx"),
    PropertyName: ToStringPointer("Author"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentProperty(ctx, request)

GetDocumentPropertyOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentPropertyOnlineRequest{
    Document: requestDocument,
    PropertyName: ToStringPointer("Author"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentPropertyOnline(ctx, request)

GetDocumentProtection.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentProtectionRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentProtection(ctx, request)

GetDocumentProtectionOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentProtectionOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentProtectionOnline(ctx, request)

GetDocumentStatistics.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetDocumentStatisticsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentStatistics(ctx, request)

GetDocumentStatisticsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetDocumentStatisticsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetDocumentStatisticsOnline(ctx, request)

GetDocumentWithFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"outPath": "DocumentWithFormat.text",}
request := &models.GetDocumentWithFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("text"),
    Optionals: requestOptions,
}
_, _ = wordsApi.GetDocumentWithFormat(ctx, request)

GetField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetField(ctx, request)

GetFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0/paragraphs/0",}
request := &models.GetFieldOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFieldOnline(ctx, request)

GetFields.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFieldsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFields(ctx, request)

GetFieldsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetFieldsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFieldsOnline(ctx, request)

GetFilesList.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFilesListRequest{
    Path: ToStringPointer(""),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFilesList(ctx, request)

GetFootnote.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFootnoteRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFootnote(ctx, request)

GetFootnoteOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetFootnoteOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFootnoteOnline(ctx, request)

GetFootnotes.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFootnotesRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFootnotes(ctx, request)

GetFootnotesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetFootnotesOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFootnotesOnline(ctx, request)

GetFormField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFormFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFormField(ctx, request)

GetFormFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetFormFieldOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFormFieldOnline(ctx, request)

GetFormFields.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetFormFieldsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFormFields(ctx, request)

GetFormFieldsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetFormFieldsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetFormFieldsOnline(ctx, request)

GetHeaderFooter.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFooterRequest{
    Name: ToStringPointer("Sample.docx"),
    HeaderFooterIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFooter(ctx, request)

GetHeaderFooterOfSection.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFooterOfSectionRequest{
    Name: ToStringPointer("Sample.docx"),
    HeaderFooterIndex: ToInt32Pointer(int32(0)),
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFooterOfSection(ctx, request)

GetHeaderFooterOfSectionOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFooterOfSectionOnlineRequest{
    Document: requestDocument,
    HeaderFooterIndex: ToInt32Pointer(int32(0)),
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFooterOfSectionOnline(ctx, request)

GetHeaderFooterOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFooterOnlineRequest{
    Document: requestDocument,
    HeaderFooterIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFooterOnline(ctx, request)

GetHeaderFooters.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFootersRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionPath: ToStringPointer(""),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFooters(ctx, request)

GetHeaderFootersOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetHeaderFootersOnlineRequest{
    Document: requestDocument,
    SectionPath: ToStringPointer(""),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetHeaderFootersOnline(ctx, request)

GetInfo.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
request := &models.GetInfoRequest{
}
_, _, _ = wordsApi.GetInfo(ctx, request)

GetList.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetListRequest{
    Name: ToStringPointer("TestGetLists.doc"),
    ListId: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetList(ctx, request)

GetListOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetListOnlineRequest{
    Document: requestDocument,
    ListId: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetListOnline(ctx, request)

GetLists.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetListsRequest{
    Name: ToStringPointer("TestGetLists.doc"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetLists(ctx, request)

GetListsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetListsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetListsOnline(ctx, request)

GetOfficeMathObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetOfficeMathObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetOfficeMathObject(ctx, request)

GetOfficeMathObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetOfficeMathObjectOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetOfficeMathObjectOnline(ctx, request)

GetOfficeMathObjects.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetOfficeMathObjectsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetOfficeMathObjects(ctx, request)

GetOfficeMathObjectsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetOfficeMathObjectsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetOfficeMathObjectsOnline(ctx, request)

GetParagraph.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetParagraphRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraph(ctx, request)

GetParagraphFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetParagraphFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphFormat(ctx, request)

GetParagraphFormatOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetParagraphFormatOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphFormatOnline(ctx, request)

GetParagraphListFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetParagraphListFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphListFormat(ctx, request)

GetParagraphListFormatOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{}
request := &models.GetParagraphListFormatOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphListFormatOnline(ctx, request)

GetParagraphOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetParagraphOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphOnline(ctx, request)

GetParagraphs.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetParagraphsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphs(ctx, request)

GetParagraphsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0",}
request := &models.GetParagraphsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphsOnline(ctx, request)

GetParagraphTabStops.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetParagraphTabStopsRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphTabStops(ctx, request)

GetParagraphTabStopsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetParagraphTabStopsOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetParagraphTabStopsOnline(ctx, request)

GetPublicKey.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
request := &models.GetPublicKeyRequest{
}
_, _, _ = wordsApi.GetPublicKey(ctx, request)

GetRangeText.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
request := &models.GetRangeTextRequest{
    Name: ToStringPointer("Sample.docx"),
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRangeText(ctx, request)

GetRangeTextOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
request := &models.GetRangeTextOnlineRequest{
    Document: requestDocument,
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRangeTextOnline(ctx, request)

GetRun.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetRunRequest{
    Name: ToStringPointer("Sample.docx"),
    ParagraphPath: ToStringPointer("paragraphs/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRun(ctx, request)

GetRunFont.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetRunFontRequest{
    Name: ToStringPointer("Sample.docx"),
    ParagraphPath: ToStringPointer("paragraphs/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRunFont(ctx, request)

GetRunFontOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetRunFontOnlineRequest{
    Document: requestDocument,
    ParagraphPath: ToStringPointer("paragraphs/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRunFontOnline(ctx, request)

GetRunOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetRunOnlineRequest{
    Document: requestDocument,
    ParagraphPath: ToStringPointer("paragraphs/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRunOnline(ctx, request)

GetRuns.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetRunsRequest{
    Name: ToStringPointer("Sample.docx"),
    ParagraphPath: ToStringPointer("sections/0/paragraphs/0"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRuns(ctx, request)

GetRunsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetRunsOnlineRequest{
    Document: requestDocument,
    ParagraphPath: ToStringPointer("sections/0/paragraphs/0"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetRunsOnline(ctx, request)

GetSection.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetSectionRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSection(ctx, request)

GetSectionOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetSectionOnlineRequest{
    Document: requestDocument,
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSectionOnline(ctx, request)

GetSectionPageSetup.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetSectionPageSetupRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSectionPageSetup(ctx, request)

GetSectionPageSetupOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetSectionPageSetupOnlineRequest{
    Document: requestDocument,
    SectionIndex: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSectionPageSetupOnline(ctx, request)

GetSections.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetSectionsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSections(ctx, request)

GetSectionsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetSectionsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetSectionsOnline(ctx, request)

GetStructuredDocumentTag.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
request := &models.GetStructuredDocumentTagRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStructuredDocumentTag(ctx, request)

GetStructuredDocumentTagOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
request := &models.GetStructuredDocumentTagOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStructuredDocumentTagOnline(ctx, request)

GetStructuredDocumentTags.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
request := &models.GetStructuredDocumentTagsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStructuredDocumentTags(ctx, request)

GetStructuredDocumentTagsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
request := &models.GetStructuredDocumentTagsOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStructuredDocumentTagsOnline(ctx, request)

GetStyle.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetStyleRequest{
    Name: ToStringPointer("Sample.docx"),
    StyleName: ToStringPointer("Heading 1"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStyle(ctx, request)

GetStyleFromDocumentElement.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetStyleFromDocumentElementRequest{
    Name: ToStringPointer("Sample.docx"),
    StyledNodePath: ToStringPointer("paragraphs/1/paragraphFormat"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStyleFromDocumentElement(ctx, request)

GetStyleFromDocumentElementOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetStyleFromDocumentElementOnlineRequest{
    Document: requestDocument,
    StyledNodePath: ToStringPointer("paragraphs/1/paragraphFormat"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStyleFromDocumentElementOnline(ctx, request)

GetStyleOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetStyleOnlineRequest{
    Document: requestDocument,
    StyleName: ToStringPointer("Heading 1"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStyleOnline(ctx, request)

GetStyles.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetStylesRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStyles(ctx, request)

GetStylesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetStylesOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetStylesOnline(ctx, request)

GetTable.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTableRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTable(ctx, request)

GetTableCell.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTableCellRequest{
    Name: ToStringPointer("Sample.docx"),
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableCell(ctx, request)

GetTableCellFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTableCellFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableCellFormat(ctx, request)

GetTableCellFormatOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTableCellFormatOnlineRequest{
    Document: requestDocument,
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableCellFormatOnline(ctx, request)

GetTableCellOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTableCellOnlineRequest{
    Document: requestDocument,
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableCellOnline(ctx, request)

GetTableOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTableOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableOnline(ctx, request)

GetTableProperties.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTablePropertiesRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableProperties(ctx, request)

GetTablePropertiesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTablePropertiesOnlineRequest{
    Document: requestDocument,
    Index: ToInt32Pointer(int32(1)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTablePropertiesOnline(ctx, request)

GetTableRow.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTableRowRequest{
    Name: ToStringPointer("Sample.docx"),
    TablePath: ToStringPointer("tables/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableRow(ctx, request)

GetTableRowFormat.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTableRowFormatRequest{
    Name: ToStringPointer("Sample.docx"),
    TablePath: ToStringPointer("sections/0/tables/2"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableRowFormat(ctx, request)

GetTableRowFormatOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTableRowFormatOnlineRequest{
    Document: requestDocument,
    TablePath: ToStringPointer("sections/0/tables/2"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableRowFormatOnline(ctx, request)

GetTableRowOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTableRowOnlineRequest{
    Document: requestDocument,
    TablePath: ToStringPointer("tables/1"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTableRowOnline(ctx, request)

GetTables.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := map[string]interface{}{}
request := &models.GetTablesRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTables(ctx, request)

GetTablesOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := map[string]interface{}{}
request := &models.GetTablesOnlineRequest{
    Document: requestDocument,
    Optionals: requestOptions,
}
_, _, _ = wordsApi.GetTablesOnline(ctx, request)

InsertBookmark.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestBookmarkStartRange := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.0.0.0"),
    Offset: ToInt32Pointer(int32(0)),
}
requestBookmarkEndRange := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.0.0.0"),
    Offset: ToInt32Pointer(int32(0)),
}
requestBookmark := models.BookmarkInsert{
    StartRange: &requestBookmarkStartRange,
    EndRange: &requestBookmarkEndRange,
    Name: ToStringPointer("new_bookmark"),
    Text: ToStringPointer("Some text"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertBookmarkRequest{
    Name: ToStringPointer("Sample.docx"),
    Bookmark: &requestBookmark,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertBookmark(ctx, insertRequest)

InsertBookmarkOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestBookmarkStartRange := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.0.0.0"),
    Offset: ToInt32Pointer(int32(0)),
}
requestBookmarkEndRange := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.0.0.0"),
    Offset: ToInt32Pointer(int32(0)),
}
requestBookmark := models.BookmarkInsert{
    StartRange: &requestBookmarkStartRange,
    EndRange: &requestBookmarkEndRange,
    Name: ToStringPointer("new_bookmark"),
    Text: ToStringPointer("Some text"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertBookmarkOnlineRequest{
    Document: requestDocument,
    Bookmark: &requestBookmark,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertBookmarkOnline(ctx, insertRequest)

InsertComment.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestCommentRangeStart := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.3.0.3"),
    Offset: ToInt32Pointer(int32(0)),
}
requestCommentRangeEnd := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.3.0.3"),
    Offset: ToInt32Pointer(int32(0)),
}
requestComment := models.CommentInsert{
    RangeStart: &requestCommentRangeStart,
    RangeEnd: &requestCommentRangeEnd,
    Initial: ToStringPointer("IA"),
    Author: ToStringPointer("John Doe"),
    Text: ToStringPointer("A new Comment"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertCommentRequest{
    Name: ToStringPointer("Sample.docx"),
    Comment: &requestComment,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertComment(ctx, insertRequest)

InsertCommentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestCommentRangeStart := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.3.0.3"),
    Offset: ToInt32Pointer(int32(0)),
}
requestCommentRangeEnd := models.NewDocumentPosition{
    NodeId: ToStringPointer("0.3.0.3"),
    Offset: ToInt32Pointer(int32(0)),
}
requestComment := models.CommentInsert{
    RangeStart: &requestCommentRangeStart,
    RangeEnd: &requestCommentRangeEnd,
    Initial: ToStringPointer("IA"),
    Author: ToStringPointer("John Doe"),
    Text: ToStringPointer("A new Comment"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertCommentOnlineRequest{
    Document: requestDocument,
    Comment: &requestComment,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertCommentOnline(ctx, insertRequest)

InsertCustomXmlPart.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestCustomXmlPart := models.CustomXmlPartInsert{
    Id: ToStringPointer("hello"),
    Data: ToStringPointer("<data>Hello world</data>"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertCustomXmlPartRequest{
    Name: ToStringPointer("Sample.docx"),
    CustomXmlPart: &requestCustomXmlPart,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertCustomXmlPart(ctx, insertRequest)

InsertCustomXmlPartOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestCustomXmlPart := models.CustomXmlPartInsert{
    Id: ToStringPointer("hello"),
    Data: ToStringPointer("<data>Hello world</data>"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertCustomXmlPartOnlineRequest{
    Document: requestDocument,
    CustomXmlPart: &requestCustomXmlPart,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertCustomXmlPartOnline(ctx, insertRequest)

InsertDrawingObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDrawingObject := models.DrawingObjectInsert{
    Height: ToFloat64Pointer(0),
    Left: ToFloat64Pointer(0),
    Top: ToFloat64Pointer(0),
    Width: ToFloat64Pointer(0),
    RelativeHorizontalPosition: ToStringPointer("Margin"),
    RelativeVerticalPosition: ToStringPointer("Margin"),
    WrapType: ToStringPointer("Inline"),
}
requestImageFile, _ := os.Open("Image.png")
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertDrawingObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    DrawingObject: &requestDrawingObject,
    ImageFile: requestImageFile,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertDrawingObject(ctx, insertRequest)

InsertDrawingObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestDrawingObject := models.DrawingObjectInsert{
    Height: ToFloat64Pointer(0),
    Left: ToFloat64Pointer(0),
    Top: ToFloat64Pointer(0),
    Width: ToFloat64Pointer(0),
    RelativeHorizontalPosition: ToStringPointer("Margin"),
    RelativeVerticalPosition: ToStringPointer("Margin"),
    WrapType: ToStringPointer("Inline"),
}
requestImageFile, _ := os.Open("Image.png")
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertDrawingObjectOnlineRequest{
    Document: requestDocument,
    DrawingObject: &requestDrawingObject,
    ImageFile: requestImageFile,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertDrawingObjectOnline(ctx, insertRequest)

InsertField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestField := models.FieldInsert{
    FieldCode: ToStringPointer("{ NUMPAGES }"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    Field: &requestField,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertField(ctx, insertRequest)

InsertFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestField := models.FieldInsert{
    FieldCode: ToStringPointer("{ NUMPAGES }"),
}
insertRequestOptions := map[string]interface{}{"nodePath": "sections/0/paragraphs/0",}
insertRequest := &models.InsertFieldOnlineRequest{
    Document: requestDocument,
    Field: &requestField,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertFieldOnline(ctx, insertRequest)

InsertFootnote.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestFootnoteDto := models.FootnoteInsert{
    FootnoteType: ToStringPointer("Endnote"),
    Text: ToStringPointer("test endnote"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertFootnoteRequest{
    Name: ToStringPointer("Sample.docx"),
    FootnoteDto: &requestFootnoteDto,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertFootnote(ctx, insertRequest)

InsertFootnoteOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestFootnoteDto := models.FootnoteInsert{
    FootnoteType: ToStringPointer("Endnote"),
    Text: ToStringPointer("test endnote"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertFootnoteOnlineRequest{
    Document: requestDocument,
    FootnoteDto: &requestFootnoteDto,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertFootnoteOnline(ctx, insertRequest)

InsertFormField.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestFormField := models.FormFieldTextInput{
    Name: ToStringPointer("FullName"),
    Enabled: ToBoolPointer(true),
    CalculateOnExit: ToBoolPointer(true),
    StatusText: ToStringPointer(""),
    TextInputType: ToStringPointer("Regular"),
    TextInputDefault: ToStringPointer("123"),
    TextInputFormat: ToStringPointer("UPPERCASE"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertFormFieldRequest{
    Name: ToStringPointer("Sample.docx"),
    FormField: &requestFormField,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertFormField(ctx, insertRequest)

InsertFormFieldOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestFormField := models.FormFieldTextInput{
    Name: ToStringPointer("FullName"),
    Enabled: ToBoolPointer(true),
    CalculateOnExit: ToBoolPointer(true),
    StatusText: ToStringPointer(""),
    TextInputType: ToStringPointer("Regular"),
    TextInputDefault: ToStringPointer("123"),
    TextInputFormat: ToStringPointer("UPPERCASE"),
}
insertRequestOptions := map[string]interface{}{"nodePath": "sections/0/paragraphs/0",}
insertRequest := &models.InsertFormFieldOnlineRequest{
    Document: requestDocument,
    FormField: &requestFormField,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertFormFieldOnline(ctx, insertRequest)

InsertHeaderFooter.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertHeaderFooterRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionPath: ToStringPointer(""),
    HeaderFooterType: ToStringPointer("FooterEven"),
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertHeaderFooter(ctx, insertRequest)

InsertHeaderFooterOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertHeaderFooterOnlineRequest{
    Document: requestDocument,
    SectionPath: ToStringPointer(""),
    HeaderFooterType: ToStringPointer("FooterEven"),
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertHeaderFooterOnline(ctx, insertRequest)

InsertList.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestListInsert := models.ListInsert{
    Template: ToStringPointer("OutlineLegal"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertListRequest{
    Name: ToStringPointer("TestGetLists.doc"),
    ListInsert: &requestListInsert,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertList(ctx, insertRequest)

InsertListOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestListInsert := models.ListInsert{
    Template: ToStringPointer("OutlineLegal"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertListOnlineRequest{
    Document: requestDocument,
    ListInsert: &requestListInsert,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertListOnline(ctx, insertRequest)

InsertOrUpdateParagraphTabStop.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTabStopInsertDto := models.TabStopInsert{
    Alignment: ToStringPointer("Left"),
    Leader: ToStringPointer("None"),
    Position: ToFloat64Pointer(100.0),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertOrUpdateParagraphTabStopRequest{
    Name: ToStringPointer("Sample.docx"),
    Index: ToInt32Pointer(int32(0)),
    TabStopInsertDto: &requestTabStopInsertDto,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertOrUpdateParagraphTabStop(ctx, insertRequest)

InsertOrUpdateParagraphTabStopOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestTabStopInsertDto := models.TabStopInsert{
    Alignment: ToStringPointer("Left"),
    Leader: ToStringPointer("None"),
    Position: ToFloat64Pointer(72),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertOrUpdateParagraphTabStopOnlineRequest{
    Document: requestDocument,
    TabStopInsertDto: &requestTabStopInsertDto,
    Index: ToInt32Pointer(int32(0)),
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertOrUpdateParagraphTabStopOnline(ctx, insertRequest)

InsertPageNumbers.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestPageNumber := models.PageNumber{
    Alignment: ToStringPointer("center"),
    Format: ToStringPointer("{PAGE} of {NUMPAGES}"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertPageNumbersRequest{
    Name: ToStringPointer("Sample.docx"),
    PageNumber: &requestPageNumber,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertPageNumbers(ctx, insertRequest)

InsertPageNumbersOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestPageNumber := models.PageNumber{
    Alignment: ToStringPointer("center"),
    Format: ToStringPointer("{PAGE} of {NUMPAGES}"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertPageNumbersOnlineRequest{
    Document: requestDocument,
    PageNumber: &requestPageNumber,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertPageNumbersOnline(ctx, insertRequest)

InsertParagraph.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestParagraph := models.ParagraphInsert{
    Text: ToStringPointer("This is a new paragraph for your document"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertParagraphRequest{
    Name: ToStringPointer("Sample.docx"),
    Paragraph: &requestParagraph,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertParagraph(ctx, insertRequest)

InsertParagraphOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestParagraph := models.ParagraphInsert{
    Text: ToStringPointer("This is a new paragraph for your document"),
}
insertRequestOptions := map[string]interface{}{"nodePath": "sections/0",}
insertRequest := &models.InsertParagraphOnlineRequest{
    Document: requestDocument,
    Paragraph: &requestParagraph,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertParagraphOnline(ctx, insertRequest)

InsertRun.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestRun := models.RunInsert{
    Text: ToStringPointer("run with text"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertRunRequest{
    Name: ToStringPointer("Sample.docx"),
    ParagraphPath: ToStringPointer("paragraphs/1"),
    Run: &requestRun,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertRun(ctx, insertRequest)

InsertRunOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestRun := models.RunInsert{
    Text: ToStringPointer("run with text"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertRunOnlineRequest{
    Document: requestDocument,
    ParagraphPath: ToStringPointer("paragraphs/1"),
    Run: &requestRun,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertRunOnline(ctx, insertRequest)

InsertStructuredDocumentTag.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestStructuredDocumentTag := models.StructuredDocumentTagInsert{
    SdtType: ToStringPointer("ComboBox"),
    Level: ToStringPointer("Inline"),
}
insertRequestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
insertRequest := &models.InsertStructuredDocumentTagRequest{
    Name: ToStringPointer("Sample.docx"),
    StructuredDocumentTag: &requestStructuredDocumentTag,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertStructuredDocumentTag(ctx, insertRequest)

InsertStructuredDocumentTagOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestStructuredDocumentTag := models.StructuredDocumentTagInsert{
    SdtType: ToStringPointer("ComboBox"),
    Level: ToStringPointer("Inline"),
}
insertRequestOptions := map[string]interface{}{"nodePath": "sections/0/body/paragraphs/0",}
insertRequest := &models.InsertStructuredDocumentTagOnlineRequest{
    Document: requestDocument,
    StructuredDocumentTag: &requestStructuredDocumentTag,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertStructuredDocumentTagOnline(ctx, insertRequest)

InsertStyle.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestStyleInsert := models.StyleInsert{
    StyleName: ToStringPointer("My Style"),
    StyleType: ToStringPointer("Paragraph"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertStyleRequest{
    Name: ToStringPointer("Sample.docx"),
    StyleInsert: &requestStyleInsert,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertStyle(ctx, insertRequest)

InsertStyleOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestStyleInsert := models.StyleInsert{
    StyleName: ToStringPointer("My Style"),
    StyleType: ToStringPointer("Paragraph"),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertStyleOnlineRequest{
    Document: requestDocument,
    StyleInsert: &requestStyleInsert,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertStyleOnline(ctx, insertRequest)

InsertTable.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestTable := models.TableInsert{
    ColumnsCount: ToInt32Pointer(int32(5)),
    RowsCount: ToInt32Pointer(int32(4)),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableRequest{
    Name: ToStringPointer("Sample.docx"),
    Table: &requestTable,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTable(ctx, insertRequest)

InsertTableCell.Go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestCell := models.TableCellInsert{
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableCellRequest{
    Name: ToStringPointer("Sample.docx"),
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Cell: &requestCell,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTableCell(ctx, insertRequest)

InsertTableCellOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestCell := models.TableCellInsert{
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableCellOnlineRequest{
    Document: requestDocument,
    TableRowPath: ToStringPointer("sections/0/tables/2/rows/0"),
    Cell: &requestCell,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTableCellOnline(ctx, insertRequest)

InsertTableOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestTable := models.TableInsert{
    ColumnsCount: ToInt32Pointer(int32(5)),
    RowsCount: ToInt32Pointer(int32(4)),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableOnlineRequest{
    Document: requestDocument,
    Table: &requestTable,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTableOnline(ctx, insertRequest)

InsertTableRow.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestRow := models.TableRowInsert{
    ColumnsCount: ToInt32Pointer(int32(5)),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableRowRequest{
    Name: ToStringPointer("Sample.docx"),
    TablePath: ToStringPointer("sections/0/tables/2"),
    Row: &requestRow,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTableRow(ctx, insertRequest)

InsertTableRowOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestRow := models.TableRowInsert{
    ColumnsCount: ToInt32Pointer(int32(5)),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertTableRowOnlineRequest{
    Document: requestDocument,
    TablePath: ToStringPointer("sections/0/tables/2"),
    Row: &requestRow,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertTableRowOnline(ctx, insertRequest)

InsertWatermarkImage.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
insertRequestOptions := map[string]interface{}{"imageFile": nil,
"image": "Sample.png",}
insertRequest := &models.InsertWatermarkImageRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertWatermarkImage(ctx, insertRequest)

InsertWatermarkImageOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestImageFile, _ := os.Open("Image.png")
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertWatermarkImageOnlineRequest{
    Document: requestDocument,
    ImageFile: requestImageFile,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertWatermarkImageOnline(ctx, insertRequest)

InsertWatermarkText.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestWatermarkText := models.WatermarkText{
    Text: ToStringPointer("This is the text"),
    RotationAngle: ToFloat64Pointer(90.0),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertWatermarkTextRequest{
    Name: ToStringPointer("Sample.docx"),
    WatermarkText: &requestWatermarkText,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertWatermarkText(ctx, insertRequest)

InsertWatermarkTextOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestWatermarkText := models.WatermarkText{
    Text: ToStringPointer("This is the text"),
    RotationAngle: ToFloat64Pointer(90),
}
insertRequestOptions := map[string]interface{}{}
insertRequest := &models.InsertWatermarkTextOnlineRequest{
    Document: requestDocument,
    WatermarkText: &requestWatermarkText,
    Optionals: insertRequestOptions,
}
_, _, _ = wordsApi.InsertWatermarkTextOnline(ctx, insertRequest)

LinkHeaderFootersToPrevious.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
linkHeaderFootersToPreviousOptions := map[string]interface{}{}
linkHeaderFootersToPrevious := &models.LinkHeaderFootersToPreviousRequest{
    Name: ToStringPointer("Sample.docx"),
    SectionIndex: ToInt32Pointer(int32(1)),
    Optionals: linkHeaderFootersToPreviousOptions,
}
_, _ = wordsApi.LinkHeaderFootersToPrevious(ctx, linkHeaderFootersToPrevious)

LoadWebDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDataSaveOptions := models.DocSaveOptionsData{
    FileName: ToStringPointer("google.doc"),
    DmlEffectsRenderingMode: ToStringPointer("None"),
    DmlRenderingMode: ToStringPointer("DrawingML"),
    UpdateSdtContent: ToBoolPointer(false),
    ZipOutput: ToBoolPointer(false),
}
requestData := models.LoadWebDocumentData{
    LoadingDocumentUrl: ToStringPointer("http://google.com"),
    SaveOptions: &requestDataSaveOptions,
}
loadRequestOptions := map[string]interface{}{}
loadRequest := &models.LoadWebDocumentRequest{
    Data: &requestData,
    Optionals: loadRequestOptions,
}
_, _, _ = wordsApi.LoadWebDocument(ctx, loadRequest)

MoveFile.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
moveRequestOptions := map[string]interface{}{}
moveRequest := &models.MoveFileRequest{
    DestPath: ToStringPointer("MoveFileSample.docx"),
    SrcPath: ToStringPointer("Sample.docx"),
    Optionals: moveRequestOptions,
}
_, _ = wordsApi.MoveFile(ctx, moveRequest)

MoveFolder.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
moveRequestOptions := map[string]interface{}{}
moveRequest := &models.MoveFolderRequest{
    DestPath: ToStringPointer("/TestMoveFolderDest_Sample"),
    SrcPath: ToStringPointer("/TestMoveFolderSrc"),
    Optionals: moveRequestOptions,
}
_, _ = wordsApi.MoveFolder(ctx, moveRequest)

OptimizeDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestOptions := models.OptimizationOptions{
    MsWordVersion: ToStringPointer("Word2002"),
}
optimizeRequestOptions := map[string]interface{}{}
optimizeRequest := &models.OptimizeDocumentRequest{
    Name: ToStringPointer("Sample.docx"),
    Options: &requestOptions,
    Optionals: optimizeRequestOptions,
}
_, _ = wordsApi.OptimizeDocument(ctx, optimizeRequest)

OptimizeDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestOptions := models.OptimizationOptions{
    MsWordVersion: ToStringPointer("Word2002"),
}
optimizeRequestOptions := map[string]interface{}{}
optimizeRequest := &models.OptimizeDocumentOnlineRequest{
    Document: requestDocument,
    Options: &requestOptions,
    Optionals: optimizeRequestOptions,
}
_, _, _ = wordsApi.OptimizeDocumentOnline(ctx, optimizeRequest)

ProtectDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestProtectionRequest := models.ProtectionRequest{
    Password: ToStringPointer("123"),
    ProtectionType: ToStringPointer("ReadOnly"),
}
protectRequestOptions := map[string]interface{}{}
protectRequest := &models.ProtectDocumentRequest{
    Name: ToStringPointer("Sample.docx"),
    ProtectionRequest: &requestProtectionRequest,
    Optionals: protectRequestOptions,
}
_, _, _ = wordsApi.ProtectDocument(ctx, protectRequest)

ProtectDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestProtectionRequest := models.ProtectionRequest{
    NewPassword: ToStringPointer("123"),
}
protectRequestOptions := map[string]interface{}{}
protectRequest := &models.ProtectDocumentOnlineRequest{
    Document: requestDocument,
    ProtectionRequest: &requestProtectionRequest,
    Optionals: protectRequestOptions,
}
_, _, _ = wordsApi.ProtectDocumentOnline(ctx, protectRequest)

RejectAllRevisions.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
rejectRequestOptions := map[string]interface{}{}
rejectRequest := &models.RejectAllRevisionsRequest{
    Name: ToStringPointer("Sample.docx"),
    Optionals: rejectRequestOptions,
}
_, _, _ = wordsApi.RejectAllRevisions(ctx, rejectRequest)

RejectAllRevisionsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
rejectRequestOptions := map[string]interface{}{}
rejectRequest := &models.RejectAllRevisionsOnlineRequest{
    Document: requestDocument,
    Optionals: rejectRequestOptions,
}
_, _, _ = wordsApi.RejectAllRevisionsOnline(ctx, rejectRequest)

RemoveRange.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
removeRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
removeRequest := &models.RemoveRangeRequest{
    Name: ToStringPointer("Sample.docx"),
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    Optionals: removeRequestOptions,
}
_, _, _ = wordsApi.RemoveRange(ctx, removeRequest)

RemoveRangeOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
removeRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
removeRequest := &models.RemoveRangeOnlineRequest{
    Document: requestDocument,
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    Optionals: removeRequestOptions,
}
_, _, _ = wordsApi.RemoveRangeOnline(ctx, removeRequest)

RenderDrawingObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderDrawingObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderDrawingObject(ctx, renderRequest)

RenderDrawingObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
renderRequestOptions := map[string]interface{}{"nodePath": "sections/0",}
renderRequest := &models.RenderDrawingObjectOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderDrawingObjectOnline(ctx, renderRequest)

RenderMathObject.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderMathObjectRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderMathObject(ctx, renderRequest)

RenderMathObjectOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderMathObjectOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderMathObjectOnline(ctx, renderRequest)

RenderPage.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderPageRequest{
    Name: ToStringPointer("Sample.docx"),
    PageIndex: ToInt32Pointer(int32(1)),
    Format: ToStringPointer("jpg"),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderPage(ctx, renderRequest)

RenderPageOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderPageOnlineRequest{
    Document: requestDocument,
    PageIndex: ToInt32Pointer(int32(1)),
    Format: ToStringPointer("jpg"),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderPageOnline(ctx, renderRequest)

RenderParagraph.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderParagraphRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderParagraph(ctx, renderRequest)

RenderParagraphOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderParagraphOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderParagraphOnline(ctx, renderRequest)

RenderTable.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderTableRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderTable(ctx, renderRequest)

RenderTableOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
renderRequestOptions := map[string]interface{}{}
renderRequest := &models.RenderTableOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("png"),
    Index: ToInt32Pointer(int32(0)),
    Optionals: renderRequestOptions,
}
_, _ = wordsApi.RenderTableOnline(ctx, renderRequest)

ReplaceText.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestReplaceText := models.ReplaceTextParameters{
    OldValue: ToStringPointer("Testing"),
    NewValue: ToStringPointer("Aspose testing"),
}
replaceRequestOptions := map[string]interface{}{}
replaceRequest := &models.ReplaceTextRequest{
    Name: ToStringPointer("Sample.docx"),
    ReplaceText: &requestReplaceText,
    Optionals: replaceRequestOptions,
}
_, _, _ = wordsApi.ReplaceText(ctx, replaceRequest)

ReplaceTextOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestReplaceText := models.ReplaceTextParameters{
    OldValue: ToStringPointer("aspose"),
    NewValue: ToStringPointer("aspose new"),
}
replaceRequestOptions := map[string]interface{}{}
replaceRequest := &models.ReplaceTextOnlineRequest{
    Document: requestDocument,
    ReplaceText: &requestReplaceText,
    Optionals: replaceRequestOptions,
}
_, _, _ = wordsApi.ReplaceTextOnline(ctx, replaceRequest)

ReplaceWithText.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestRangeText := models.ReplaceRange{
    Text: ToStringPointer("Replaced header"),
}
replaceRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
replaceRequest := &models.ReplaceWithTextRequest{
    Name: ToStringPointer("Sample.docx"),
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    RangeText: &requestRangeText,
    Optionals: replaceRequestOptions,
}
_, _, _ = wordsApi.ReplaceWithText(ctx, replaceRequest)

ReplaceWithTextOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestRangeText := models.ReplaceRange{
    Text: ToStringPointer("Replaced header"),
}
replaceRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
replaceRequest := &models.ReplaceWithTextOnlineRequest{
    Document: requestDocument,
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    RangeText: &requestRangeText,
    Optionals: replaceRequestOptions,
}
_, _, _ = wordsApi.ReplaceWithTextOnline(ctx, replaceRequest)

ResetCache.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
resetRequest := &models.ResetCacheRequest{
}
_, _ = wordsApi.ResetCache(ctx, resetRequest)

SaveAs.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestSaveOptionsData := models.DocxSaveOptionsData{
    FileName: ToStringPointer("FromPdfToDoc.docx"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsRequest{
    Name: ToStringPointer("Sample.docx"),
    SaveOptionsData: &requestSaveOptionsData,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAs(ctx, saveRequest)

SaveAs_1.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)

// Open test.docx
file, err := os.Open("test_doc.pdf")
if err != nil {
  fmt.Println(err)
}

format := "docx"

var jsonStr = `{
  "outPath":"test_doc.docx"    
}`

jsonMap := make(map[string]interface{})

json.Unmarshal([]byte(jsonStr), &jsonMap)

// Convert Document to docx (The output doc will be saved in cloud storage)
wordsApi.ConvertDocument(ctx, file, format, jsonMap)

SaveAs_2.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
FileName := "test.docx"

// Open test.docx
file, err := os.Open(FileName)
if err != nil {
  fmt.Println(err)
}

// Upload test.docx
_, _, err1 := wordsApi.UploadFile(ctx, file, FileName, nil)

if err1 != nil {
  fmt.Println(err1)
}

saveOptions := api.SaveOptionsData{
  SaveFormat: "html",
  FileName:   "test_doc.html",
}

var jsonStr = `{
  "storage":"First Storage"    
}`
// Populate map[string]interface{}
jsonMap := make(map[string]interface{})

json.Unmarshal([]byte(jsonStr), &jsonMap)

// Save Document to html (The output doc will be saved in cloud storage)
_, response, _ := wordsApi.SaveAs(ctx, FileName, saveOptions, jsonMap)

fmt.Println(response.Status)

SaveAsOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("test_multi_pages.docx")
requestSaveOptionsData := models.HtmlSaveOptionsData{
    FileName: ToStringPointer("/TestSaveAsHtml.html"),
    CssStyleSheetType: ToStringPointer("External"),
    CssStyleSheetFileName: ToStringPointer("/TestSaveAsHtml.css"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsOnlineRequest{
    Document: requestDocument,
    SaveOptionsData: &requestSaveOptionsData,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsOnline(ctx, saveRequest)

SaveAsOnline_1.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestSaveOptionsData := models.SaveOptionsData{
    SaveFormat: ToStringPointer("pdf"),
    FileName: ToStringPointer("Sample_out.pdf"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsOnlineRequest{
    Document: requestDocument,
    SaveOptionsData: &requestSaveOptionsData,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsOnline(ctx, saveRequest)

SaveAsOnline_2.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
requestSaveOptionsData := models.SaveOptionsData{
    SaveFormat: ToStringPointer("html"),
    FileName: ToStringPointer("Sample_out.html"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsOnlineRequest{
    Document: requestDocument,
    SaveOptionsData: &requestSaveOptionsData,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsOnline(ctx, saveRequest)

SaveAsRange.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocumentParameters := models.RangeDocument{
    DocumentName: ToStringPointer("NewDocument.docx"),
}
saveRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
saveRequest := &models.SaveAsRangeRequest{
    Name: ToStringPointer("Sample.docx"),
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    DocumentParameters: &requestDocumentParameters,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsRange(ctx, saveRequest)

SaveAsRangeOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.doc")
requestDocumentParameters := models.RangeDocument{
    DocumentName: ToStringPointer("NewDocument.docx"),
}
saveRequestOptions := map[string]interface{}{"rangeEndIdentifier": "id0.0.1",}
saveRequest := &models.SaveAsRangeOnlineRequest{
    Document: requestDocument,
    RangeStartIdentifier: ToStringPointer("id0.0.0"),
    DocumentParameters: &requestDocumentParameters,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsRangeOnline(ctx, saveRequest)

SaveAsTiff.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestSaveOptions := models.TiffSaveOptionsData{
    FileName: ToStringPointer("Image.tiff"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsTiffRequest{
    Name: ToStringPointer("Sample.docx"),
    SaveOptions: &requestSaveOptions,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsTiff(ctx, saveRequest)

SaveAsTiffOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("test_multi_pages.docx")
requestSaveOptions := models.TiffSaveOptionsData{
    FileName: ToStringPointer("Image.tiff"),
}
saveRequestOptions := map[string]interface{}{}
saveRequest := &models.SaveAsTiffOnlineRequest{
    Document: requestDocument,
    SaveOptions: &requestSaveOptions,
    Optionals: saveRequestOptions,
}
_, _, _ = wordsApi.SaveAsTiffOnline(ctx, saveRequest)

Search.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
searchRequestOptions := map[string]interface{}{}
searchRequest := &models.SearchRequest{
    Name: ToStringPointer("Sample.docx"),
    Pattern: ToStringPointer("aspose"),
    Optionals: searchRequestOptions,
}
_, _, _ = wordsApi.Search(ctx, searchRequest)

SearchOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
searchRequestOptions := map[string]interface{}{}
searchRequest := &models.SearchOnlineRequest{
    Document: requestDocument,
    Pattern: ToStringPointer("aspose"),
    Optionals: searchRequestOptions,
}
_, _, _ = wordsApi.SearchOnline(ctx, searchRequest)

SplitDocument.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
splitRequestOptions := map[string]interface{}{"destFileName": "SplitDocument.text",
"from": int32(1),
"to": int32(2),}
splitRequest := &models.SplitDocumentRequest{
    Name: ToStringPointer("Sample.docx"),
    Format: ToStringPointer("text"),
    Optionals: splitRequestOptions,
}
_, _, _ = wordsApi.SplitDocument(ctx, splitRequest)

SplitDocument_1.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
filePath := "test_multi_pages.docx"
fileName := "test_multi_pages.docx"

// Open document
file, err := os.Open(filePath)
if err != nil {
  fmt.Println(err)
}

// Upload document
_, _, err1 := wordsApi.UploadFile(ctx, file, fileName, nil)

if err1 != nil {
  fmt.Println(err1)
}

options := map[string]interface{}{
  "storage":      "First Storage",
  "destFileName": "split_all_out.zip",
  "format":       "png",
  "from":1,
  "to":2,
  "zipOutput":true,
}

// Split the document
splitDocumentResponse, response, _ := wordsApi.SplitDocument(ctx, fileName, options)

fmt.Println(response.Status)
fmt.Println(splitDocumentResponse.SplitResult.SourceDocument.Href)

SplitDocument_2.go

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
filePath := "test_multi_pages.docx"
fileName := "test_multi_pages.docx"

// Open document
file, err := os.Open(filePath)
if err != nil {
  fmt.Println(err)
}

// Upload document
_, _, err1 := wordsApi.UploadFile(ctx, file, fileName, nil)

if err1 != nil {
  fmt.Println(err1)
}

options := map[string]interface{}{
  "storage":      "First Storage",
  "destFileName": "split_all_out.pdf",
  "format":       "pdf",
  "from":1,
  "to":2,
}

// Split the document
splitDocumentResponse, response, _ := wordsApi.SplitDocument(ctx, fileName, options)

fmt.Println(response.Status)
fmt.Println(splitDocumentResponse.SplitResult.SourceDocument.Href)

SplitDocumentOnline.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
splitRequestOptions := map[string]interface{}{"destFileName": "SplitDocument.text",
"from": int32(1),
"to": int32(2),}
splitRequest := &models.SplitDocumentOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("text"),
    Optionals: splitRequestOptions,
}
_, _, _ = wordsApi.SplitDocumentOnline(ctx, splitRequest)

SplitDocumentOnline_1.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
splitRequestOptions := map[string]interface{}{"from": int32(1),
"to": int32(2),}
splitRequest := &models.SplitDocumentOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("png"),
    Optionals: splitRequestOptions,
}
_, _, _ = wordsApi.SplitDocumentOnline(ctx, splitRequest)

SplitDocumentOnline_2.go

import (
    "os"
    "github.com/aspose-words-cloud/aspose-words-cloud-go/dev/api/models")

config, _ := models.NewConfiguration("config.json")
wordsApi, ctx, _ := api.CreateWordsApi(config)
requestDocument, _ := os.Open("Sample.docx")
splitRequestOptions := map[string]interface{}{"from": int32(1),
"to": int32(2),}
splitRequest := &models.SplitDocumentOnlineRequest{
    Document: requestDocument,
    Format: ToStringPointer("pdf"),
    Optionals: splitRequestOptions,
}
_, _, _ = wordsApi.SplitDocumentOnline(ctx, splitRequest)