@agility/management-sdk 0.1.0

package/dist/apiMethods/containerMethods.d.ts

@@ -0,0 +1,16 @@
+import { Options } from "../models/options";
+import { ClientInstance } from "./clientInstance";
+import { Container } from "../models/container";
+import { Notification } from "../models/notification";
+export declare class ContainerMethods {
+    _options: Options;
+    _clientInstance: ClientInstance;
+    constructor(options: Options);
+    getContainerByID(id: number): Promise<Container>;
+    getContainerByReferenceName(referenceName: string): Promise<Container>;
+    getContainerSecurity(id: number): Promise<Container>;
+    getContainerList(): Promise<Container[]>;
+    getNotificationList(id: number): Promise<Notification[]>;
+    saveContainer(container: Container): Promise<Container>;
+    deleteContainer(id: number): Promise<string>;
+}

package/dist/apiMethods/containerMethods.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerMethods = void 0;
+const clientInstance_1 = require("./clientInstance");
+const exception_1 = require("../models/exception");
+class ContainerMethods {
+    constructor(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance();
+    }
+    getContainerByID(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/${id}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the contianer for id: ${id}`, err);
+            }
+        });
+    }
+    getContainerByReferenceName(referenceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/${referenceName}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the contianer for referenceName: ${referenceName}`, err);
+            }
+        });
+    }
+    getContainerSecurity(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/${id}/security`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the contianer for id: ${id}`, err);
+            }
+        });
+    }
+    getContainerList() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/list`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the contianer list`, err);
+            }
+        });
+    }
+    getNotificationList(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/${id}/notifications`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the notifications for contianer id: ${id}`, err);
+            }
+        });
+    }
+    saveContainer(container) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, container);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to save the contianer`, err);
+            }
+        });
+    }
+    deleteContainer(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `container/${id}`;
+                const resp = yield this._clientInstance.executeDelete(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to delete the contianer for id: ${id}`, err);
+            }
+        });
+    }
+}
+exports.ContainerMethods = ContainerMethods;

package/dist/apiMethods/contentMethods.d.ts

@@ -0,0 +1,20 @@
+import { Options } from "../models/options";
+import { ClientInstance } from "./clientInstance";
+import { ContentItem, ContentList } from "../models/contentItem";
+import { BatchMethods } from "./batchMethods";
+export declare class ContentMethods {
+    _options: Options;
+    _clientInstance: ClientInstance;
+    _batchMethods: BatchMethods;
+    constructor(options: Options);
+    getContentItem(contentID: number): Promise<ContentItem>;
+    publishContent(contentID: number, comments?: string): Promise<number[]>;
+    unPublishContent(contentID: number, comments?: string): Promise<number[]>;
+    contentRequestApproval(contentID: number, comments?: string): Promise<number[]>;
+    approveContent(contentID: number, comments?: string): Promise<number[]>;
+    declineContent(contentID: number, comments?: string): Promise<number[]>;
+    deleteContent(contentID: number, comments?: string): Promise<number[]>;
+    saveContentItem(contentItem: ContentItem): Promise<number[]>;
+    saveContentItems(contentItems: ContentItem[]): Promise<number[]>;
+    getContentItems(referenceName: string, filter?: string, fields?: string, sortDirection?: string, sortField?: string, take?: number, skip?: number): Promise<ContentList>;
+}

package/dist/apiMethods/contentMethods.js

@@ -0,0 +1,175 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContentMethods = void 0;
+const clientInstance_1 = require("./clientInstance");
+const batchMethods_1 = require("./batchMethods");
+const exception_1 = require("../models/exception");
+class ContentMethods {
+    constructor(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance();
+        this._batchMethods = new batchMethods_1.BatchMethods(this._options);
+    }
+    getContentItem(contentID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    publishContent(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}/publish?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to publish the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    unPublishContent(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}/unpublish?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to un-publish the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    contentRequestApproval(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}/request-approval?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to request approval the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    approveContent(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}/approve?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to approve the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    declineContent(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}/decline?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to decline the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    deleteContent(contentID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/${contentID}?comments=${comments}`;
+                const resp = yield this._clientInstance.executeDelete(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to delete the content for id: ${contentID}`, err);
+            }
+        });
+    }
+    saveContentItem(contentItem) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, contentItem);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception('Unable to create content.', err);
+            }
+        });
+    }
+    saveContentItems(contentItems) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/item/multi`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, contentItems);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let contentIDs = [];
+                batch.items.forEach(element => contentIDs.push(element.itemID));
+                return contentIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception('Unable to create contents.', err);
+            }
+        });
+    }
+    getContentItems(referenceName, filter = '', fields = null, sortDirection = null, sortField = null, take = 50, skip = 0) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/list/${referenceName}?filter=${filter}&fields=${fields}&sortDirection=${sortDirection}&sortField=${sortField}&take=${take}&skip=${skip}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable retreive the content details for reference name: ${referenceName}`, err);
+            }
+        });
+    }
+}
+exports.ContentMethods = ContentMethods;

package/dist/apiMethods/instanceUserMethods.d.ts

@@ -0,0 +1,13 @@
+import { Options } from "../models/options";
+import { ClientInstance } from "./clientInstance";
+import { InstanceUser } from "../models/instanceUser";
+import { WebsiteUser } from "../models/websiteUser";
+import { InstanceRole } from "../models/instanceRole";
+export declare class InstanceUserMethods {
+    _options: Options;
+    _clientInstance: ClientInstance;
+    constructor(options: Options);
+    getUsers(): Promise<WebsiteUser>;
+    saveUser(emailAddress: string, roles: InstanceRole[], firstName?: string, lastName?: string): Promise<InstanceUser>;
+    deleteUser(userId: number): Promise<string>;
+}

package/dist/apiMethods/instanceUserMethods.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InstanceUserMethods = void 0;
+const clientInstance_1 = require("./clientInstance");
+const exception_1 = require("../models/exception");
+class InstanceUserMethods {
+    constructor(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance();
+    }
+    getUsers() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `user/list`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive users.`, err);
+            }
+        });
+    }
+    saveUser(emailAddress, roles, firstName = null, lastName = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `user/save?emailAddress=${emailAddress}&firstName=${firstName}&lastName=${lastName}`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, roles);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive users.`, err);
+            }
+        });
+    }
+    deleteUser(userId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `user/delete/${userId}`;
+                const resp = yield this._clientInstance.executeDelete(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to delete the user for id: ${userId}`, err);
+            }
+        });
+    }
+}
+exports.InstanceUserMethods = InstanceUserMethods;

package/dist/apiMethods/modelMethods.d.ts

@@ -0,0 +1,13 @@
+import { Options } from "../models/options";
+import { ClientInstance } from "./clientInstance";
+import { Model } from "../models/model";
+export declare class ModelMethods {
+    _options: Options;
+    _clientInstance: ClientInstance;
+    constructor(options: Options);
+    getContentModel(id: number): Promise<Model>;
+    getContentModules(includeDefaults: boolean, includeModules?: boolean): Promise<Model[]>;
+    getPageModules(includeDefault: boolean): Promise<Model[]>;
+    saveModel(model: Model): Promise<Model>;
+    deleteModel(id: number): Promise<string>;
+}

package/dist/apiMethods/modelMethods.js

@@ -0,0 +1,81 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModelMethods = void 0;
+const clientInstance_1 = require("./clientInstance");
+const exception_1 = require("../models/exception");
+class ModelMethods {
+    constructor(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance();
+    }
+    getContentModel(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `model/${id}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive model for id: ${id}.`, err);
+            }
+        });
+    }
+    getContentModules(includeDefaults, includeModules = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `model/list/${includeDefaults}?includeModules=${includeModules}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive content modules.`, err);
+            }
+        });
+    }
+    getPageModules(includeDefault) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `model/list-page-modules/${includeDefault}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive page modules.`, err);
+            }
+        });
+    }
+    saveModel(model) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `model`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, model);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to save the model.`, err);
+            }
+        });
+    }
+    deleteModel(id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `model/${id}`;
+                const resp = yield this._clientInstance.executeDelete(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to delete the model`, err);
+            }
+        });
+    }
+}
+exports.ModelMethods = ModelMethods;

package/dist/apiMethods/pageMethods.d.ts

@@ -0,0 +1,20 @@
+import { Options } from "../models/options";
+import { ClientInstance } from "./clientInstance";
+import { PageItem } from "../models/pageItem";
+import { Sitemap } from "../models/sitemap";
+import { BatchMethods } from "./batchMethods";
+export declare class PageMethods {
+    _options: Options;
+    _clientInstance: ClientInstance;
+    _batchMethods: BatchMethods;
+    constructor(options: Options);
+    getSitemap(): Promise<Sitemap[]>;
+    getPage(pageID: number): Promise<PageItem>;
+    publishPage(pageID: number, comments?: string): Promise<number[]>;
+    unPublishPage(pageID: number, comments?: string): Promise<number[]>;
+    pageRequestApproval(pageID: number, comments?: string): Promise<number[]>;
+    approvePage(pageID: number, comments?: string): Promise<number[]>;
+    declinePage(pageID: number, comments?: string): Promise<number[]>;
+    deletePage(pageID: number, comments?: string): Promise<number[]>;
+    savePage(pageItem: PageItem, parentPageID?: number, placeBeforePageItemID?: number): Promise<number[]>;
+}

package/dist/apiMethods/pageMethods.js

@@ -0,0 +1,159 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageMethods = void 0;
+const clientInstance_1 = require("./clientInstance");
+const batchMethods_1 = require("./batchMethods");
+const exception_1 = require("../models/exception");
+class PageMethods {
+    constructor(options) {
+        this._options = options;
+        this._clientInstance = new clientInstance_1.ClientInstance();
+        this._batchMethods = new batchMethods_1.BatchMethods(this._options);
+    }
+    getSitemap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/sitemap`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive sitemap.`, err);
+            }
+        });
+    }
+    getPage(pageID) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                return resp.data;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to retreive page for id ${pageID}.`, err);
+            }
+        });
+    }
+    publishPage(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}/publish?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to publish the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    unPublishPage(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}/unpublish?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to un-publish the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    pageRequestApproval(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}/request-approval?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to request approval the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    approvePage(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}/approve?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to approve the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    declinePage(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}/decline?comments=${comments}`;
+                const resp = yield this._clientInstance.executeGet(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to decline the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    deletePage(pageID, comments = null) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page/${pageID}?comments=${comments}`;
+                const resp = yield this._clientInstance.executeDelete(apiPath, this._options);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to delete the page for id: ${pageID}`, err);
+            }
+        });
+    }
+    savePage(pageItem, parentPageID = -1, placeBeforePageItemID = -1) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                let apiPath = `${this._options.locale}/page?parentPageID=${parentPageID}&placeBeforePageItemID=${placeBeforePageItemID}`;
+                const resp = yield this._clientInstance.executePost(apiPath, this._options, pageItem);
+                let batchID = resp.data;
+                var batch = yield this._batchMethods.Retry(() => __awaiter(this, void 0, void 0, function* () { return yield this._batchMethods.getBatch(batchID); }));
+                let pageIDs = [];
+                batch.items.forEach(element => pageIDs.push(element.itemID));
+                return pageIDs;
+            }
+            catch (err) {
+                throw new exception_1.Exception(`Unable to create page. ${err}`, err);
+            }
+        });
+    }
+}
+exports.PageMethods = PageMethods;